0.7 baby!

Allows more fine tuned latencies.

AUTHORS

@@ -3,3 +3,6 @@ Hans-Kristian Arntzen - <[email protected]>
 
 Devin J. Pohly - <[email protected]>
    - Joypad axis support
+
+Chris Moeller - <[email protected]> 
+   - CoreAudio audio driver

Makefile

@@ -9,13 +9,20 @@ HEADERS = $(wildcard */*.h) $(wildcard *.h)
 LIBS = -lm
 DEFINES = -DHAVE_CONFIG_H
 
-ifneq ($(findstring Darwin,$(shell uname -a)),)
+ifneq ($(findstring Darwin,$(OS)),)
    OSX := 1
    LIBS += -framework AppKit
 else
    OSX := 0
 endif
 
+BSD_LOCAL_INC =
+DYLIB_LIB = -ldl
+ifneq ($(findstring BSD,$(OS)),)
+   BSD_LOCAL_INC = -I/usr/local/include
+   DYLIB_LIB = -lc
+endif
+
 ifeq ($(HAVE_SRC), 1)
    LIBS += $(SRC_LIBS)
    DEFINES += $(SRC_CFLAGS)
@@ -33,19 +40,29 @@ endif
 
 ifeq ($(HAVE_RSOUND), 1)
    OBJ += audio/rsound.o
-   LIBS += -lrsound
+   LIBS += $(RSOUND_LIBS)
+   DEFINES += $(RSOUND_CFLAGS)
 endif
 
 ifeq ($(HAVE_OSS), 1)
    OBJ += audio/oss.o
 endif
+ifeq ($(HAVE_OSS_BSD), 1)
+   OBJ += audio/oss.o
+endif
+ifeq ($(HAVE_OSS_LIB), 1)
+   LIBS += -lossaudio
+endif
+
 ifeq ($(HAVE_ALSA), 1)
    OBJ += audio/alsa.o
-   LIBS += -lasound
+   LIBS += $(ALSA_LIBS)
+   DEFINES += $(ALSA_CFLAGS)
 endif
 ifeq ($(HAVE_ROAR), 1)
    OBJ += audio/roar.o
-   LIBS += -lroar
+   LIBS += $(ROAR_LIBS)
+   DEFINES += $(ROAR_CFLAGS)
 endif
 ifeq ($(HAVE_AL), 1)
    OBJ += audio/openal.o
@@ -66,9 +83,14 @@ ifeq ($(HAVE_PULSE), 1)
    DEFINES += $(PULSE_CFLAGS)
 endif
 
+ifeq ($(HAVE_COREAUDIO), 1)
+   OBJ += audio/coreaudio.o
+   LIBS += -framework CoreServices -framework CoreAudio -framework AudioUnit
+endif
+
 ifeq ($(HAVE_SDL), 1)
-   OBJ += gfx/sdl.o gfx/gl.o input/sdl.o audio/sdl.o audio/buffer.o
-   DEFINES += $(SDL_CFLAGS)
+   OBJ += gfx/sdl.o gfx/gl.o input/sdl.o audio/sdl.o fifo_buffer.o
+   DEFINES += $(SDL_CFLAGS) $(BSD_LOCAL_INC)
    LIBS += $(SDL_LIBS)
 ifeq ($(OSX),1)
    LIBS += -framework OpenGL
@@ -79,7 +101,8 @@ endif
 
 ifeq ($(HAVE_XVIDEO), 1)
    OBJ += gfx/xvideo.o input/x11_input.o
-   LIBS += -lX11 -lXext -lXv
+   LIBS += $(XVIDEO_LIBS)
+   DEFINES += $(XVIDEO_CFLAGS)
 endif
 
 ifeq ($(HAVE_CG), 1)
@@ -95,7 +118,7 @@ endif
 
 ifeq ($(HAVE_DYLIB), 1)
    OBJ += gfx/ext.o audio/ext.o
-   LIBS += -ldl
+   LIBS += $(DYLIB_LIB)
 endif
 
 ifeq ($(HAVE_FREETYPE), 1)
@@ -111,12 +134,12 @@ endif
 
 ifeq ($(HAVE_FFMPEG), 1)
    OBJ += record/ffemu.o
-   LIBS += $(AVCODEC_LIBS) $(AVCORE_LIBS) $(AVFORMAT_LIBS) $(AVUTIL_LIBS) $(SWSCALE_LIBS)
-   DEFINES += $(AVCODEC_CFLAGS) $(AVCORE_CFLAGS) $(AVFORMAT_CFLAGS) $(AVUTIL_CFLAGS) $(SWSCALE_CFLAGS)
+   LIBS += $(AVCODEC_LIBS) $(AVFORMAT_LIBS) $(AVUTIL_LIBS) $(SWSCALE_LIBS)
+   DEFINES += $(AVCODEC_CFLAGS) $(AVFORMAT_CFLAGS) $(AVUTIL_CFLAGS) $(SWSCALE_CFLAGS)
 endif
 
 ifeq ($(HAVE_DYNAMIC), 1)
-   LIBS += -ldl
+   LIBS += $(DYLIB_LIB)
 else
    LIBS += $(libsnes)
 endif

Makefile.win32

@@ -13,12 +13,14 @@ HAVE_SDL_IMAGE = 1
 HAVE_XML = 1
 HAVE_FREETYPE = 1
 HAVE_XAUDIO = 1
+HAVE_DSOUND = 1
 HAVE_RSOUND = 1
 HAVE_DYLIB = 1
 HAVE_NETPLAY = 1
 HAVE_FBO = 1
 HAVE_CG = 1
 HAVE_PYTHON = 1
+HAVE_FFMPEG = 0
 libsnes ?= -lsnes
 
 LIBS = -lm
@@ -37,7 +39,7 @@ else
 endif
 
 ifeq ($(HAVE_SDL), 1)
-   OBJ += gfx/sdl.o gfx/gl.o input/sdl.o audio/sdl.o audio/buffer.o
+   OBJ += gfx/sdl.o gfx/gl.o input/sdl.o audio/sdl.o fifo_buffer.o
    LIBS += $(SDL_LIBS) -lopengl32
    DEFINES += $(SDL_CFLAGS) -DHAVE_SDL
 endif
@@ -58,6 +60,12 @@ ifeq ($(HAVE_XAUDIO), 1)
    DEFINES += -DHAVE_XAUDIO
 endif
 
+ifeq ($(HAVE_DSOUND), 1)
+   OBJ += audio/dsound.o
+   DEFINES += -DHAVE_DSOUND
+   LIBS += -ldxguid -ldsound
+endif
+
 ifeq ($(HAVE_RSOUND), 1)
    OBJ += audio/rsound.o
    DEFINES += -DHAVE_RSOUND
@@ -108,10 +116,16 @@ endif
 
 ifeq ($(HAVE_DINPUT), 1)
    LIBS += -ldinput8 -ldxguid -lole32
-   DEFINES += -DHAVE_DINPUT
+   DEFINES += -DHAVE_DINPUT -Iffmpeg
    OBJ += input/dinput.o
 endif
 
+ifeq ($(HAVE_FFMPEG), 1)
+   LIBS += -lavformat -lavcodec -lavutil -lswscale -lws2_32 -lzlib1
+   DEFINES += -DHAVE_FFMPEG
+   OBJ += record/ffemu.o
+endif
+
 ifneq ($(V),1)
    Q := @
 endif
@@ -148,7 +162,7 @@ clean:
 	rm -f tools/*.o
 
 dist: all
-	zip -r ssnes-win32-0.5.2.zip $(TARGET) ssnes.cfg snes.dll libxml2.dll iconv.dll zlib1.dll SDL.dll freetype6.dll xaudio-c.dll rsound.dll pthreadGC2.dll cg.dll cgGL.dll libjpeg-8.dll libpng15-15.dll python32.dll SDL_image.dll $(JTARGET)
+	zip -r ssnes-win32-0.7.zip $(TARGET) ssnes.cfg snes.dll libxml2.dll iconv.dll zlib1.dll SDL.dll freetype6.dll xaudio-c.dll rsound.dll pthreadGC2.dll cg.dll cgGL.dll libjpeg-8.dll libpng15-15.dll python32.dll SDL_image.dll $(JTARGET)
 
 libs:
 	wget https://github.com/downloads/Themaister/SSNES/SSNES-win32-libs.zip --no-check-certificate

Makefile.win64

@@ -12,6 +12,7 @@ HAVE_SDL = 1
 HAVE_XML = 1
 HAVE_FREETYPE = 1
 HAVE_XAUDIO = 1
+HAVE_DSOUND = 1
 HAVE_RSOUND = 0
 HAVE_DYLIB = 1
 HAVE_NETPLAY = 1
@@ -36,7 +37,7 @@ else
 endif
 
 ifeq ($(HAVE_SDL), 1)
-   OBJ += gfx/sdl.o gfx/gl.o input/sdl.o audio/sdl.o audio/buffer.o
+   OBJ += gfx/sdl.o gfx/gl.o input/sdl.o audio/sdl.o fifo_buffer.o
    LIBS += $(SDL_LIBS) -lopengl32 
    DEFINES += $(SDL_CFLAGS) -DHAVE_SDL
 endif
@@ -52,6 +53,12 @@ ifeq ($(HAVE_XAUDIO), 1)
    DEFINES += -DHAVE_XAUDIO
 endif
 
+ifeq ($(HAVE_DSOUND), 1)
+   OBJ += audio/dsound.o
+   DEFINES += -DHAVE_DSOUND
+   LIBS += -ldxguid -ldsound
+endif
+
 ifeq ($(HAVE_RSOUND), 1)
    OBJ += audio/rsound.o
    DEFINES += -DHAVE_RSOUND
@@ -142,7 +149,7 @@ clean:
 	rm -f tools/*.o
 
 dist: all
-	zip -r ssnes-win64-0.5.zip $(TARGET) ssnes.cfg snes.dll xaudio-c.dll README.win32.txt $(JTARGET)
+	zip -r ssnes-win64-0.7.zip $(TARGET) ssnes.cfg snes.dll xaudio-c.dll README.win32.txt $(JTARGET)
 
 libs:
 	wget https://github.com/downloads/Themaister/SSNES/ssnes-win64-libs.zip --no-check-certificate

audio/alsa.c

@@ -18,7 +18,7 @@
 
 #include "driver.h"
 #include <stdlib.h>
-#include <alsa/asoundlib.h>
+#include <asoundlib.h>
 #include "general.h"
 
 #define TRY_ALSA(x) if ( x < 0 ) { \

audio/coreaudio.c

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

audio/dsound.c

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

audio/ext/ssnes_dsp.h

@@ -30,7 +30,7 @@ extern "C" {
 #define SSNES_TRUE 1
 #endif
 
-#define SSNES_DSP_API_VERSION 2
+#define SSNES_DSP_API_VERSION 3
 
 typedef struct ssnes_dsp_info
 {
@@ -94,7 +94,7 @@ typedef struct ssnes_dsp_plugin
    void (*process)(void *data, ssnes_dsp_output_t *output, 
          const ssnes_dsp_input_t *input);
 
-      // Frees the handle.
+   // Frees the handle.
    void (*free)(void *data);
 
    // API version used to compile the plugin.
@@ -110,6 +110,11 @@ typedef struct ssnes_dsp_plugin
 
    // Human readable identification string.
    const char *ident;
+
+   // Called every frame, allows creating a GUI main loop in the main thread.
+   // GUI events can be processed here in a non-blocking fashion.
+   // Can be set to NULL to ignore it.
+   void (*events)(void *data);
 } ssnes_dsp_plugin_t;
 
 // Called by SSNES at startup to get the callback struct.

audio/jack.c

@@ -127,9 +127,12 @@ static size_t find_buffersize(jack_t *jd, int latency)
 static void* __jack_init(const char* device, unsigned rate, unsigned latency)
 {
    jack_t *jd = calloc(1, sizeof(jack_t));
-   if ( jd == NULL )
+   if (!jd)
       return NULL;
 
+   pthread_cond_init(&jd->cond, NULL);
+   pthread_mutex_init(&jd->cond_lock, NULL);
+   
    const char **jports = NULL;
 
    jd->client = jack_client_open("SSNES", JackNullOption, NULL);
@@ -148,7 +151,6 @@ static void* __jack_init(const char* device, unsigned rate, unsigned latency)
       SSNES_ERR("Failed to register ports.\n");
       goto error;
    }
-
    
    char *dest_ports[2];
    jports = jack_get_ports(jd->client, NULL, NULL, JackPortIsPhysical | JackPortIsInput);
@@ -158,6 +160,18 @@ static void* __jack_init(const char* device, unsigned rate, unsigned latency)
       goto error;
    }
 
+   size_t bufsize = find_buffersize(jd, latency);
+   SSNES_LOG("JACK: Internal buffer size: %d frames.\n", (int)(bufsize / sizeof(jack_default_audio_sample_t)));
+   for (int i = 0; i < 2; i++)
+   {
+      jd->buffer[i] = jack_ringbuffer_create(bufsize);
+      if (jd->buffer[i] == NULL)
+      {
+         SSNES_ERR("Failed to create buffers.\n");
+         goto error;
+      }
+   }
+
    int parsed = parse_ports(dest_ports, jports);
 
    if (jack_activate(jd->client) < 0)
@@ -178,22 +192,7 @@ static void* __jack_init(const char* device, unsigned rate, unsigned latency)
    for (int i = 0; i < parsed; i++)
       free(dest_ports[i]);
 
-   size_t bufsize = find_buffersize(jd, latency);
-
-   SSNES_LOG("JACK: Internal buffer size: %d frames.\n", (int)(bufsize / sizeof(jack_default_audio_sample_t)));
-   for (int i = 0; i < 2; i++)
-   {
-      jd->buffer[i] = jack_ringbuffer_create(bufsize);
-      if (jd->buffer[i] == NULL)
-      {
-         SSNES_ERR("Failed to create buffers.\n");
-         goto error;
-      }
-   }
-
-   pthread_cond_init(&jd->cond, NULL);
-   pthread_mutex_init(&jd->cond_lock, NULL);
-
+  
    jack_free(jports);
    return jd;
 

audio/oss.c

@@ -15,28 +15,44 @@
  *  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
 
 #include "driver.h"
+#include "general.h"
 #include <stdlib.h>
+
+#ifdef HAVE_OSS_BSD
+#include <soundcard.h>
+#else
 #include <sys/soundcard.h>
+#endif
+
 #include <fcntl.h>
 #include <sys/ioctl.h>
 #include <unistd.h>
 #include <errno.h>
 #include <stdio.h>
 
+#ifdef HAVE_OSS_BSD
+#define DEFAULT_OSS_DEV "/dev/audio"
+#else
+#define DEFAULT_OSS_DEV "/dev/dsp"
+#endif
+
 static void* __oss_init(const char* device, unsigned rate, unsigned latency)
 {
    int *fd = calloc(1, sizeof(int));
-   if ( fd == NULL )
+   if (fd == NULL)
       return NULL;
 
-   const char *oss_device = "/dev/dsp";
+   const char *oss_device = DEFAULT_OSS_DEV;
 
-   if ( device != NULL )
+   if (device != NULL)
       oss_device = device;
 
-   if ( (*fd = open(oss_device, O_WRONLY)) < 0 )
+   if ((*fd = open(oss_device, O_WRONLY)) < 0)
    {
       free(fd);
       return NULL;
@@ -45,7 +61,7 @@ static void* __oss_init(const char* device, unsigned rate, unsigned latency)
    int frags = (latency * rate * 4)/(1000 * (1 << 9));
    int frag = (frags << 16) | 9;
 
-   if ( ioctl(*fd, SNDCTL_DSP_SETFRAGMENT, &frag) < 0 )
+   if (ioctl(*fd, SNDCTL_DSP_SETFRAGMENT, &frag) < 0)
    {
       close(*fd);
       free(fd);
@@ -53,23 +69,24 @@ static void* __oss_init(const char* device, unsigned rate, unsigned latency)
    }
 
    int channels = 2;
-   int format = AFMT_S16_LE;
+   int format = is_little_endian() ?
+      AFMT_S16_LE : AFMT_S16_BE;
 
-   if ( ioctl(*fd, SNDCTL_DSP_CHANNELS, &channels) < 0 )
+   if (ioctl(*fd, SNDCTL_DSP_CHANNELS, &channels) < 0)
    {
       close(*fd);
       free(fd);
       return NULL;
    }
 
-   if ( ioctl(*fd, SNDCTL_DSP_SETFMT, &format) < 0 )
+   if (ioctl(*fd, SNDCTL_DSP_SETFMT, &format) < 0)
    {
       close(*fd);
       free(fd);
       return NULL;
    }
 
-   if ( ioctl(*fd, SNDCTL_DSP_SPEED, &rate) < 0 )
+   if (ioctl(*fd, SNDCTL_DSP_SPEED, &rate) < 0)
    {
       close(*fd);
       free(fd);
@@ -83,13 +100,13 @@ static ssize_t __oss_write(void* data, const void* buf, size_t size)
 {
    int *fd = data;
 
-   if ( size == 0 )
+   if (size == 0)
       return 0;
 
    ssize_t ret;
-   if ( (ret = write(*fd, buf, size)) <= 0 )
+   if ((ret = write(*fd, buf, size)) <= 0)
    {
-      if ( (fcntl(*fd, F_GETFL) & O_NONBLOCK) && errno == EAGAIN )
+      if ((fcntl(*fd, F_GETFL) & O_NONBLOCK) && errno == EAGAIN)
          return 0;
       return -1;
    }
@@ -139,9 +156,4 @@ const audio_driver_t audio_oss = {
    .free = __oss_free,
    .ident = "oss"
 };
-
-   
-
-
-   
    

audio/pulse.c

@@ -59,18 +59,6 @@ static void __pulse_free(void *data)
    }
 }
 
-static inline uint8_t is_little_endian(void)
-{
-   union
-   {
-      uint16_t x;
-      uint8_t y[2];
-   } u;
-
-   u.x = 1;
-   return u.y[0];
-}
-
 static void context_state_cb(pa_context *c, void *data)
 {
    pa_t *pa = data;

audio/rsound.c

@@ -19,7 +19,7 @@
 #include "driver.h"
 #include <stdlib.h>
 #include <rsound.h>
-#include "buffer.h"
+#include "fifo_buffer.h"
 #include <stdbool.h>
 #include "SDL.h"
 
@@ -29,7 +29,7 @@ typedef struct rsd
    bool nonblock;
    volatile bool has_error;
 
-   rsound_fifo_buffer_t *buffer;
+   fifo_buffer_t *buffer;
 
    SDL_mutex *cond_lock;
    SDL_cond *cond;
@@ -39,9 +39,9 @@ static ssize_t audio_cb(void *data, size_t bytes, void *userdata)
 {
    rsd_t *rsd = userdata;
 
-   size_t avail = rsnd_fifo_read_avail(rsd->buffer);
+   size_t avail = fifo_read_avail(rsd->buffer);
    size_t write_size = bytes > avail ? avail : bytes;
-   rsnd_fifo_read(rsd->buffer, data, write_size);
+   fifo_read(rsd->buffer, data, write_size);
    SDL_CondSignal(rsd->cond);
 
    return write_size;
@@ -71,7 +71,7 @@ static void* __rsd_init(const char* device, unsigned rate, unsigned latency)
    rsd->cond_lock = SDL_CreateMutex();
    rsd->cond = SDL_CreateCond();
 
-   rsd->buffer = rsnd_fifo_new(1024 * 4);
+   rsd->buffer = fifo_new(1024 * 4);
 
    int channels = 2;
    int format = RSD_S16_NE;
@@ -108,9 +108,9 @@ static ssize_t __rsd_write(void* data, const void* buf, size_t size)
    if (rsd->nonblock)
    {
       rsd_callback_lock(rsd->rd);
-      size_t avail = rsnd_fifo_write_avail(rsd->buffer);
+      size_t avail = fifo_write_avail(rsd->buffer);
       size_t write_amt = avail > size ? size : avail;
-      rsnd_fifo_write(rsd->buffer, buf, write_amt);
+      fifo_write(rsd->buffer, buf, write_amt);
       rsd_callback_unlock(rsd->rd);
       return write_amt;
    }
@@ -120,7 +120,7 @@ static ssize_t __rsd_write(void* data, const void* buf, size_t size)
       while (written < size && !rsd->has_error)
       {
          rsd_callback_lock(rsd->rd);
-         size_t avail = rsnd_fifo_write_avail(rsd->buffer);
+         size_t avail = fifo_write_avail(rsd->buffer);
 
          if (avail == 0)
          {
@@ -135,7 +135,7 @@ static ssize_t __rsd_write(void* data, const void* buf, size_t size)
          else
          {
             size_t write_amt = size - written > avail ? avail : size - written;
-            rsnd_fifo_write(rsd->buffer, (const char*)buf + written, write_amt);
+            fifo_write(rsd->buffer, (const char*)buf + written, write_amt);
             rsd_callback_unlock(rsd->rd);
             written += write_amt;
          }
@@ -174,7 +174,7 @@ static void __rsd_free(void *data)
    rsd_stop(rsd->rd);
    rsd_free(rsd->rd);
 
-   rsnd_fifo_free(rsd->buffer);
+   fifo_free(rsd->buffer);
    SDL_DestroyMutex(rsd->cond_lock);
    SDL_DestroyCond(rsd->cond);
 

audio/sdl.c

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

config.def.h

@@ -57,6 +57,8 @@
 #define AUDIO_XAUDIO 9
 #define AUDIO_PULSE 10
 #define AUDIO_EXT 15
+#define AUDIO_DSOUND 16
+#define AUDIO_COREAUDIO 17
 ////////////////////////
 #define INPUT_SDL 7
 #define INPUT_X 12
@@ -82,8 +84,12 @@
 #define AUDIO_DEFAULT_DRIVER AUDIO_OSS
 #elif defined(HAVE_JACK)
 #define AUDIO_DEFAULT_DRIVER AUDIO_JACK
+#elif defined(HAVE_COREAUDIO)
+#define AUDIO_DEFAULT_DRIVER AUDIO_COREAUDIO
 #elif defined(HAVE_AL)
 #define AUDIO_DEFAULT_DRIVER AUDIO_AL
+#elif defined(HAVE_DSOUND)
+#define AUDIO_DEFAULT_DRIVER AUDIO_DSOUND
 #elif defined(HAVE_SDL)
 #define AUDIO_DEFAULT_DRIVER AUDIO_SDL
 #elif defined(HAVE_XAUDIO)
@@ -123,6 +129,9 @@ static const unsigned fullscreen_y = 0;
 // Force 16-bit colors.
 static const bool force_16bit = false;
 
+// Forcibly disable composition. Only valid on Windows Vista/7 for now.
+static const bool disable_composition = false;
+
 // Video VSYNC (recommended)
 static const bool vsync = true;
 
@@ -148,6 +157,12 @@ static const float fbo_scale_x = 2.0;
 static const float fbo_scale_y = 2.0;
 static const bool second_pass_smooth = true;
 
+// Record video assuming game runs hi-res.
+static const bool hires_record = false;
+
+// Record post-filtered (CPU filter) video rather than raw SNES output.
+static const bool post_filter_record = false;
+
 #define SNES_ASPECT_RATIO (4.0/3)
 
 ////////////////
@@ -198,7 +213,7 @@ static const bool pause_nonactive = true;
 static const unsigned autosave_interval = 0;
 
 // When being client over netplay, use keybinds for player 1 rather than player 2.
-static const bool netplay_client_swap_input = false;
+static const bool netplay_client_swap_input = true;
 
 
 ////////////////////

config.features.h

@@ -14,13 +14,19 @@ static const bool _sdl_supp = true;
 static const bool _sdl_supp = false;
 #endif
 
+#ifdef HAVE_XVIDEO
+static const bool _xvideo_supp = true;
+#else
+static const bool _xvideo_supp = false;
+#endif
+
 #ifdef HAVE_ALSA
 static const bool _alsa_supp = true;
 #else
 static const bool _alsa_supp = false;
 #endif
 
-#ifdef HAVE_OSS
+#if defined(HAVE_OSS) || defined(HAVE_OSS_BSD)
 static const bool _oss_supp = true;
 #else
 static const bool _oss_supp = false;

docs/ssnes.1

@@ -40,6 +40,10 @@ Without this flag, the save state path will be inferred from the rom path name,
 When rom is loaded from \fBstdin\fR, this flag is mandatory to define as no path can be inferred.
 Do note that save states are bound to the libsnes implementation being used. Using a different libsnes could invalidate the save state file.
 
+.TP
+\fB--fullscreen, -f\fR
+Always starts SSNES in fullscreen. Disregards settings in configuration file.
+
 .TP
 \fB--config PATH, -c PATH\fR
 Sets the configuration file path. \fBssnes\fR will use this path to load the configuration file.
@@ -80,6 +84,9 @@ When using Sufami, save ram paths will be inferred from the Sufami BIOS path, no
 \fB--mouse PORT, -m PORT\fR
 Connects a Super Nintendo Mouse into port number PORT of the emulated SNES. Possible values for PORT are 1 and 2.
 
+\fB--nodevice PORT, -N PORT\fR
+Disconnects an input device from port number PORT of the emulated SNES. Possible values for PORT are 1 and 2. This may be needed for some odd games to run properly.
+
 .TP
 \fB--scope, -p\fR
 Connects a Super Scope into port 2 of the SNES. It is controlled with your mouse.
@@ -131,6 +138,11 @@ Network port used for netplay. This defaults to 55435. This option affects both
 Attempts to apply an UPS patch to the current ROM image. No files are altered. 
 If this flag is not specified, SSNES will look for a .ups file with same basename as ROM specified.
 
+.TP
+\fB--xml MAP, -X MAP\fR
+Specifies path to XML memory map for the given ROM.
+If this flag is not specified, SSNES will look for a .xml file with same basename as ROM specified.
+
 .TP
 \fB-D, --detach\fR
 Detach from the current console. This is currently only relevant for Microsoft Windows.

driver.c

@@ -32,12 +32,15 @@ static const audio_driver_t *audio_drivers[] = {
 #ifdef HAVE_ALSA
    &audio_alsa,
 #endif
-#ifdef HAVE_OSS
+#if defined(HAVE_OSS) || defined(HAVE_OSS_BSD)
    &audio_oss,
 #endif
 #ifdef HAVE_RSOUND
    &audio_rsound,
 #endif
+#ifdef HAVE_COREAUDIO
+   &audio_coreaudio,
+#endif
 #ifdef HAVE_AL
    &audio_openal,
 #endif
@@ -53,6 +56,9 @@ static const audio_driver_t *audio_drivers[] = {
 #ifdef HAVE_XAUDIO
    &audio_xa,
 #endif
+#ifdef HAVE_DSOUND
+   &audio_dsound,
+#endif
 #ifdef HAVE_PULSE
    &audio_pulse,
 #endif
@@ -162,7 +168,7 @@ static void init_dsp_plugin(void)
    }
 
    const ssnes_dsp_plugin_t* (*SSNES_API_CALLTYPE plugin_init)(void) = 
-      (const ssnes_dsp_plugin_t *(*)(void))dylib_proc(g_extern.audio_data.dsp_lib, "ssnes_dsp_plugin_init");
+      (const ssnes_dsp_plugin_t *(SSNES_API_CALLTYPE*)(void))dylib_proc(g_extern.audio_data.dsp_lib, "ssnes_dsp_plugin_init");
    if (!plugin_init)
    {
       SSNES_ERR("Failed to find symbol \"ssnes_dsp_plugin_init\" in DSP plugin.\n");
@@ -184,7 +190,7 @@ static void init_dsp_plugin(void)
 
    SSNES_LOG("Loaded DSP plugin: \"%s\"\n", g_extern.audio_data.dsp_plugin->ident ? g_extern.audio_data.dsp_plugin->ident : "Unknown");
 
-   ssnes_dsp_info_t info = {
+   const ssnes_dsp_info_t info = {
       .input_rate = g_settings.audio.in_rate,
       .output_rate = g_settings.audio.out_rate
    };
@@ -479,12 +485,12 @@ void init_video_input(void)
 
 void uninit_video_input(void)
 {
-   if ( driver.video_data && driver.video )
-      driver.video->free(driver.video_data);
-
    if ( driver.input_data != driver.video_data && driver.input )
       driver.input->free(driver.input_data);
 
+   if ( driver.video_data && driver.video )
+      driver.video->free(driver.video_data);
+
    deinit_filter();
 
 #ifdef HAVE_XML

driver.h

@@ -158,6 +158,8 @@ extern const audio_driver_t audio_sdl;
 extern const audio_driver_t audio_xa;
 extern const audio_driver_t audio_pulse;
 extern const audio_driver_t audio_ext;
+extern const audio_driver_t audio_dsound;
+extern const audio_driver_t audio_coreaudio;
 extern const video_driver_t video_gl;
 extern const video_driver_t video_xvideo;
 extern const video_driver_t video_sdl;

fifo_buffer.c

@@ -13,9 +13,9 @@
  *  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "buffer.h"
+#include "fifo_buffer.h"
 
-struct rsound_fifo_buffer
+struct fifo_buffer
 {
    char *buffer;
    size_t bufsize;
@@ -23,9 +23,9 @@ struct rsound_fifo_buffer
    size_t end;
 };
 
-rsound_fifo_buffer_t* rsnd_fifo_new(size_t size)
+fifo_buffer_t* fifo_new(size_t size)
 {
-   rsound_fifo_buffer_t *buf = calloc(1, sizeof(*buf));
+   fifo_buffer_t *buf = calloc(1, sizeof(*buf));
    if (buf == NULL)
       return NULL;
 
@@ -40,7 +40,7 @@ rsound_fifo_buffer_t* rsnd_fifo_new(size_t size)
    return buf;
 }
 
-void rsnd_fifo_free(rsound_fifo_buffer_t* buffer)
+void fifo_free(fifo_buffer_t* buffer)
 {
    assert(buffer);
    assert(buffer->buffer);
@@ -49,7 +49,7 @@ void rsnd_fifo_free(rsound_fifo_buffer_t* buffer)
    free(buffer);
 }
 
-size_t rsnd_fifo_read_avail(rsound_fifo_buffer_t* buffer)
+size_t fifo_read_avail(fifo_buffer_t* buffer)
 {
    assert(buffer);
    assert(buffer->buffer);
@@ -61,7 +61,7 @@ size_t rsnd_fifo_read_avail(rsound_fifo_buffer_t* buffer)
    return end - first;
 }
 
-size_t rsnd_fifo_write_avail(rsound_fifo_buffer_t* buffer)
+size_t fifo_write_avail(fifo_buffer_t* buffer)
 {
    assert(buffer);
    assert(buffer->buffer);
@@ -74,12 +74,12 @@ size_t rsnd_fifo_write_avail(rsound_fifo_buffer_t* buffer)
    return (buffer->bufsize - 1) - (end - first);
 }
 
-void rsnd_fifo_write(rsound_fifo_buffer_t* buffer, const void* in_buf, size_t size)
+void fifo_write(fifo_buffer_t* buffer, const void* in_buf, size_t size)
 {
    assert(buffer);
    assert(buffer->buffer);
    assert(in_buf);
-   assert(rsnd_fifo_write_avail(buffer) >= size);
+   assert(fifo_write_avail(buffer) >= size);
 
    size_t first_write = size;
    size_t rest_write = 0;
@@ -97,12 +97,12 @@ void rsnd_fifo_write(rsound_fifo_buffer_t* buffer, const void* in_buf, size_t si
 }
 
 
-void rsnd_fifo_read(rsound_fifo_buffer_t* buffer, void* in_buf, size_t size)
+void fifo_read(fifo_buffer_t* buffer, void* in_buf, size_t size)
 {
    assert(buffer);
    assert(buffer->buffer);
    assert(in_buf);
-   assert(rsnd_fifo_read_avail(buffer) >= size);
+   assert(fifo_read_avail(buffer) >= size);
 
    size_t first_read = size;
    size_t rest_read = 0;

fifo_buffer.h

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

file.c

@@ -51,7 +51,7 @@ ssize_t read_file(const char *path, void **buf)
    long len = ftell(file);
    ssize_t rc = 0;
    rewind(file);
-   rom_buf = malloc(len);
+   rom_buf = malloc(len + 1);
    if (!rom_buf)
    {
       SSNES_ERR("Couldn't allocate memory!\n");
@@ -62,6 +62,9 @@ ssize_t read_file(const char *path, void **buf)
       SSNES_WARN("Didn't read whole file.\n");
 
    *buf = rom_buf;
+   // Allow for easy reading of strings to be safe.
+   // Will only work with sane character formatting (Unix).
+   ((char*)rom_buf)[len] = '\0'; 
    fclose(file);
    return rc;
 
@@ -73,6 +76,46 @@ error:
    return -1;
 }
 
+// Reads file content as one string.
+bool read_file_string(const char *path, char **buf)
+{
+   *buf = NULL;
+   FILE *file = fopen(path, "r");
+   if (!file)
+      goto error;
+
+   fseek(file, 0, SEEK_END);
+   long len = ftell(file) + 2; // Takes account of being able to read in EOF and '\0' at end.
+   rewind(file);
+
+   *buf = calloc(len, sizeof(char));
+   if (!*buf)
+      goto error;
+
+   char *ptr = *buf;
+
+   while (ptr && !feof(file))
+   {
+      size_t bufsize = (size_t)(((ptrdiff_t)*buf + (ptrdiff_t)len) - (ptrdiff_t)ptr);
+      fgets(ptr, bufsize, file);
+
+      ptr = strchr(ptr, '\0');
+   }
+
+   ptr = strchr(ptr, EOF);
+   if (ptr) *ptr = '\0';
+
+   fclose(file);
+   return true;
+
+error:
+   if (file)
+      fclose(file);
+   if (*buf)
+      free(*buf);
+   return false;
+}
+
 // Load SNES rom only. Applies a hack for headered ROMs.
 static ssize_t read_rom_file(FILE* file, void** buf)
 {
@@ -270,6 +313,20 @@ void save_ram_file(const char* path, int type)
       dump_to_file(path, data, size);
 }
 
+static char* load_xml_map(const char *path)
+{
+   char *xml_buf = NULL;
+   if (*path)
+   {
+      if (!read_file_string(path, &xml_buf))
+         SSNES_LOG("Did not find XML memory map in \"%s\"\n", path);
+      else
+         SSNES_LOG("Found XML memory map in \"%s\"\n", path);
+   }
+
+   return xml_buf;
+}
+
 static bool load_sgb_rom(void)
 {
    void *rom_buf = NULL;
@@ -291,14 +348,19 @@ static bool load_sgb_rom(void)
       goto error;
    }
 
+   char *xml_buf = load_xml_map(g_extern.xml_name);
+
    if (!psnes_load_cartridge_super_game_boy(
-            NULL, rom_buf, rom_len,
+            xml_buf, rom_buf, rom_len,
             NULL, extra_rom_buf, extra_rom_len))
    {
       SSNES_ERR("Cannot load SGB/GameBoy rom.\n");
       goto error;
    }
 
+   if (xml_buf)
+      free(xml_buf);
+
    if (g_extern.rom_file)
       fclose(g_extern.rom_file);
    if (extra_rom)
@@ -338,10 +400,12 @@ static bool load_bsx_rom(bool slotted)
       goto error;
    }
 
+   char *xml_buf = load_xml_map(g_extern.xml_name);
+
    if (slotted)
    {   
       if (!psnes_load_cartridge_bsx_slotted(
-               NULL, rom_buf, rom_len,
+               xml_buf, rom_buf, rom_len,
                NULL, extra_rom_buf, extra_rom_len))
       {
          SSNES_ERR("Cannot load BSX slotted rom.\n");
@@ -360,6 +424,9 @@ static bool load_bsx_rom(bool slotted)
       }
    }
 
+   if (xml_buf)
+      free(xml_buf);
+
    if (g_extern.rom_file)
       fclose(g_extern.rom_file);
    if (extra_rom)
@@ -407,8 +474,10 @@ static bool load_sufami_rom(void)
       }
    }
 
+   char *xml_buf = load_xml_map(g_extern.xml_name);
+
    if (!psnes_load_cartridge_sufami_turbo(
-            NULL, rom_buf, rom_len,
+            xml_buf, rom_buf, rom_len,
             NULL, extra_rom_buf[0], extra_rom_len[0],
             NULL, extra_rom_buf[1], extra_rom_len[1]))
    {
@@ -416,6 +485,8 @@ static bool load_sufami_rom(void)
       goto error;
    }
 
+   if (xml_buf)
+      free(xml_buf);
 
    if (g_extern.rom_file)
       fclose(g_extern.rom_file);
@@ -457,13 +528,18 @@ static bool load_normal_rom(void)
 
    SSNES_LOG("ROM size: %d bytes\n", (int)rom_len);
 
-   if (!psnes_load_cartridge_normal(NULL, rom_buf, rom_len))
+   char *xml_buf = load_xml_map(g_extern.xml_name);
+   
+   if (!psnes_load_cartridge_normal(xml_buf, rom_buf, rom_len))
    {
       SSNES_ERR("ROM file is not valid!\n");
       free(rom_buf);
       return false;
    }
 
+   if (xml_buf)
+      free(xml_buf);
+
    free(rom_buf);
    return true;
 }
@@ -572,15 +648,13 @@ char** dir_list_new(const char *dir, const char *ext)
       if (!dir_list[cur_ptr])
          goto error;
 
-      strcpy(dir_list[cur_ptr], dir);
+      strlcpy(dir_list[cur_ptr], dir, final_off);
+      strlcat(dir_list[cur_ptr], "/", final_off);
 #ifdef _WIN32
-      dir_list[cur_ptr][path_len] = '\\';
-      strcpy(&dir_list[cur_ptr][path_len + 1], utf8_buf);
+      strlcat(dir_list[cur_ptr], utf8_buf, final_off);
 #else
-      dir_list[cur_ptr][path_len] = '/';
-      strcpy(&dir_list[cur_ptr][path_len + 1], entry->d_name);
+      strlcat(dir_list[cur_ptr], entry->d_name, final_off);
 #endif
-      dir_list[cur_ptr][final_off - 1] = '\0';
 
       cur_ptr++;
       if (cur_ptr + 1 == cur_size) // Need to reserve for NULL.

general.h

@@ -89,6 +89,10 @@ struct settings
       float msg_pos_y;
 
       bool force_16bit;
+      bool disable_composition;
+
+      bool hires_record;
+      bool post_filter_record;
 
       char external_driver[256];
    } video;
@@ -147,12 +151,14 @@ struct global
    bool verbose;
    bool audio_active;
    bool video_active;
+   bool force_fullscreen;
 
    bool has_mouse[2];
    bool has_scope[2];
    bool has_justifier;
    bool has_justifiers;
    bool has_multitap;
+   bool disconnect_device[2];
 
    FILE *rom_file;
    enum ssnes_game_type game_type;
@@ -176,6 +182,7 @@ struct global
    char savefile_name_bsrm[512];
    char savestate_name[256];
    char ups_name[512];
+   char xml_name[512];
 
    unsigned state_slot;
 
@@ -302,6 +309,18 @@ static inline uint32_t next_pow2(uint32_t v)
    return v;
 }
 
+static inline uint8_t is_little_endian(void)
+{
+   union
+   {
+      uint16_t x;
+      uint8_t y[2];
+   } u;
+
+   u.x = 1;
+   return u.y[0];
+}
+
 #endif
 
 

gfx/ext.c

@@ -224,6 +224,15 @@ static bool setup_video(ext_t *ext, const video_info_t *video, const input_drive
       return false;
    }
 
+   const char *cg_shader = NULL;
+   const char *xml_shader = NULL;
+   enum ssnes_shader_type type = g_settings.video.shader_type;
+   if ((type == SSNES_SHADER_CG || type == SSNES_SHADER_AUTO) && *g_settings.video.cg_shader_path)
+      cg_shader = g_settings.video.cg_shader_path;
+   else if ((type == SSNES_SHADER_BSNES || type == SSNES_SHADER_AUTO) && *g_settings.video.bsnes_shader_path)
+      xml_shader = g_settings.video.bsnes_shader_path;
+
+
    ssnes_video_info_t info = {
       .width = video->width,
       .height = video->height,
@@ -234,8 +243,8 @@ static bool setup_video(ext_t *ext, const video_info_t *video, const input_drive
       .smooth = video->smooth,
       .input_scale = video->input_scale,
       .color_format = video->rgb32 ? SSNES_COLOR_FORMAT_ARGB8888 : SSNES_COLOR_FORMAT_XRGB1555,
-      .xml_shader = g_settings.video.bsnes_shader_path,
-      .cg_shader = g_settings.video.cg_shader_path,
+      .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
    };

gfx/gfx_common.c

@@ -25,21 +25,26 @@ static float tv_to_fps(const struct timeval *tv, const struct timeval *new_tv, i
    return frames/time;
 }
 
+static unsigned gl_frames = 0;
+
+void gfx_window_title_reset(void)
+{
+   gl_frames = 0;
+}
+
 bool gfx_window_title(char *buf, size_t size)
 {
-   static int frames = 0;
    static struct timeval tv;
    struct timeval new_tv;
    bool ret = false;
 
-   if (frames == 0)
+   if (gl_frames == 0)
    {
       gettimeofday(&tv, NULL);
       snprintf(buf, size, "%s", g_extern.title_buf);
       ret = true;
    }
-
-   if ((frames % 180) == 0 && frames > 0)
+   else if ((gl_frames % 180) == 0)
    {
       gettimeofday(&new_tv, NULL);
       struct timeval tmp_tv = tv;
@@ -47,12 +52,92 @@ bool gfx_window_title(char *buf, size_t size)
 
       float fps = tv_to_fps(&tmp_tv, &new_tv, 180);
 
-      snprintf(buf, size, "%s || FPS: %6.1f || Frames: %d", g_extern.title_buf, fps, frames);
+      snprintf(buf, size, "%s || FPS: %6.1f || Frames: %d", g_extern.title_buf, fps, gl_frames);
       ret = true;
    }
 
-   frames++;
+   gl_frames++;
    return ret;
 }
 
+#ifdef _WIN32
+#include <windows.h>
+#include "dynamic.h"
+// We only load this library once, so we let it be unloaded at application shutdown,
+// since unloading it early seems to cause issues on some systems.
+
+static dylib_t dwmlib = NULL;
+
+static void gfx_dwm_shutdown(void)
+{
+   if (dwmlib)
+      dylib_close(dwmlib);
+}
+
+void gfx_set_dwm(void)
+{
+   static bool inited = false;
+   if (inited)
+      return;
+   inited = true;
+
+   dwmlib = dylib_load("dwmapi.dll");
+   if (!dwmlib)
+   {
+      SSNES_LOG("Did not find dwmapi.dll");
+      return;
+   }
+   atexit(gfx_dwm_shutdown);
+
+   HRESULT (WINAPI *mmcss)(BOOL) = (HRESULT (WINAPI*)(BOOL))dylib_proc(dwmlib, "DwmEnableMMCSS");
+   if (mmcss)
+   {
+      SSNES_LOG("Setting multimedia scheduling for DWM.\n");
+      mmcss(TRUE);
+   }
+
+   if (!g_settings.video.disable_composition)
+      return;
+
+   HRESULT (WINAPI *composition_enable)(UINT) = (HRESULT (WINAPI*)(UINT))dylib_proc(dwmlib, "DwmEnableComposition");
+   if (!composition_enable)
+   {
+      SSNES_ERR("Did not find DwmEnableComposition ...\n");
+      return;
+   }
+
+   HRESULT ret = composition_enable(0);
+   if (FAILED(ret))
+      SSNES_ERR("Failed to set composition state ...\n");
+}
+#endif
+
+
+#include "SDL_syswm.h"
+#include "SDL.h"
+
+void gfx_get_window_size(unsigned *width, unsigned *height)
+{
+#if defined(__APPLE__) || defined(_WIN32)
+   SDL_Event evnt;
+   while (SDL_PollEvent(&evnt));
+   const SDL_VideoInfo *info = SDL_GetVideoInfo();
+   *width = info->current_w;
+   *height = info->current_h;
+#else
+   // It seems that we need to go hardcore to get the actual
+   // window sizes properly right after startup ... :D
+   SDL_SysWMinfo info;
+   SDL_VERSION(&info.version);
+   SDL_GetWMInfo(&info);
+   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

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

gfx/gl.c

@@ -125,7 +125,9 @@ static inline bool load_gl_proc(void) { return true; }
 typedef struct gl
 {
    bool vsync;
-   GLuint texture;
+   GLuint texture[2];
+   unsigned tex_index; // For use with PREV.
+   struct gl_tex_info prev_info;
    GLuint tex_filter;
 
    void *empty_buf;
@@ -153,8 +155,8 @@ typedef struct gl
    unsigned win_height;
    unsigned vp_width, vp_out_width;
    unsigned vp_height, vp_out_height;
-   unsigned last_width;
-   unsigned last_height;
+   unsigned last_width[2];
+   unsigned last_height[2];
    unsigned tex_w, tex_h;
    GLfloat tex_coords[8];
 #ifdef HAVE_FBO
@@ -255,20 +257,21 @@ static void gl_shader_set_params(unsigned width, unsigned height,
       unsigned out_width, unsigned out_height,
       unsigned frame_count,
       const struct gl_tex_info *info,
+      const struct gl_tex_info *prev_info,
       const struct gl_tex_info *fbo_info, unsigned fbo_info_cnt)
 {
 #ifdef HAVE_CG
    gl_cg_set_params(width, height, 
          tex_width, tex_height, 
          out_width, out_height, 
-         frame_count, info, fbo_info, fbo_info_cnt);
+         frame_count, info, prev_info, fbo_info, fbo_info_cnt);
 #endif
 
 #ifdef HAVE_XML
    gl_glsl_set_params(width, height, 
          tex_width, tex_height, 
          out_width, out_height, 
-         frame_count, info, fbo_info, fbo_info_cnt);
+         frame_count, info, prev_info, fbo_info, fbo_info_cnt);
 #endif
 }
 
@@ -338,7 +341,7 @@ static inline void gl_init_font(gl_t *gl, const char *font_path, unsigned font_s
          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-         glBindTexture(GL_TEXTURE_2D, gl->texture);
+         glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
       }
       else
          SSNES_WARN("Couldn't init font renderer with font \"%s\"...\n", font_path);
@@ -653,7 +656,7 @@ static void gl_render_msg(gl_t *gl, const char *msg)
    // Go back to old rendering path.
    glTexCoordPointer(2, GL_FLOAT, 2 * sizeof(GLfloat), gl->tex_coords);
    glVertexPointer(2, GL_FLOAT, 2 * sizeof(GLfloat), vertexes_flipped);
-   glBindTexture(GL_TEXTURE_2D, gl->texture);
+   glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
    glDisable(GL_BLEND);
 #endif
 }
@@ -702,6 +705,19 @@ static void check_window(gl_t *gl)
             break;
       }
    }
+
+   if (!gl->should_resize)
+   {
+      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);
+      }
+   }
 }
 
 static bool gl_frame(void *data, const void* frame, unsigned width, unsigned height, unsigned pitch, const char *msg)
@@ -712,6 +728,10 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
    gl_shader_use(1);
    gl->frame_count++;
 
+#if defined(HAVE_XML) || defined(HAVE_CG)
+   glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
+#endif
+
 #ifdef HAVE_FBO
    // Render to texture in first pass.
    if (gl->fbo_inited)
@@ -767,7 +787,7 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
          last_max_height = gl->fbo_rect[i].max_img_height;
       }
 
-      glBindTexture(GL_TEXTURE_2D, gl->texture);
+      glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
       pglBindFramebuffer(GL_FRAMEBUFFER, gl->fbo[0]);
       gl->render_to_tex = true;
       set_viewport(gl, gl->fbo_rect[0].img_width, gl->fbo_rect[0].img_height, true);
@@ -814,7 +834,7 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
          }
 
          // Go back to what we're supposed to do, render to FBO #0 :D
-         glBindTexture(GL_TEXTURE_2D, gl->texture);
+         glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
          pglBindFramebuffer(GL_FRAMEBUFFER, gl->fbo[0]);
          set_viewport(gl, gl->fbo_rect[0].img_width, gl->fbo_rect[0].img_height, true);
       }
@@ -823,10 +843,10 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
 #endif
    }
 
-   if ((width != gl->last_width || height != gl->last_height) && gl->empty_buf) // Res change. need to clear out texture.
+   if ((width != gl->last_width[gl->tex_index] || height != gl->last_height[gl->tex_index]) && gl->empty_buf) // Res change. need to clear out texture.
    {
-      gl->last_width = width;
-      gl->last_height = height;
+      gl->last_width[gl->tex_index] = width;
+      gl->last_height[gl->tex_index] = height;
       glPixelStorei(GL_UNPACK_ALIGNMENT, get_alignment(pitch));
       glPixelStorei(GL_UNPACK_ROW_LENGTH, gl->tex_w);
 
@@ -839,13 +859,13 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
 
       set_texture_coords(gl->tex_coords, xamt, yamt);
    }
-
-   // Work around a certain issue a Cg where not using TEXUNIT0
-   // in shader causes cgGLEnableTextureParameter() causes it
-   // to bind to TEXUNIT0, to avoid really funny bugs, rebind
-   // our texture.
-#ifdef HAVE_CG
-   glBindTexture(GL_TEXTURE_2D, gl->texture);
+#if defined(HAVE_XML) || defined(HAVE_CG)
+   else if (width != gl->last_width[1 - gl->tex_index] || height != gl->last_height[1 - gl->tex_index])
+   {
+      GLfloat xamt = (GLfloat)width / gl->tex_w;
+      GLfloat yamt = (GLfloat)height / gl->tex_h;
+      set_texture_coords(gl->tex_coords, xamt, yamt);
+   }
 #endif
 
 #ifdef HAVE_FBO
@@ -861,7 +881,7 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
          gl->texture_fmt, frame);
 
    struct gl_tex_info tex_info = {
-      .tex = gl->texture,
+      .tex = gl->texture[gl->tex_index],
       .input_size = {width, height},
       .tex_size = {gl->tex_w, gl->tex_h}
    };
@@ -871,7 +891,7 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
 
    glClear(GL_COLOR_BUFFER_BIT);
    gl_shader_set_params(width, height, gl->tex_w, gl->tex_h, gl->vp_width, gl->vp_height, gl->frame_count, 
-         &tex_info, fbo_tex_info, fbo_tex_info_cnt);
+         &tex_info, &gl->prev_info, fbo_tex_info, fbo_tex_info_cnt);
 
    glDrawArrays(GL_QUADS, 0, 4);
 
@@ -916,7 +936,7 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
          gl_shader_set_params(prev_rect->img_width, prev_rect->img_height, 
                prev_rect->width, prev_rect->height, 
                gl->vp_width, gl->vp_height, gl->frame_count, 
-               &tex_info, fbo_tex_info, fbo_tex_info_cnt);
+               &tex_info, &gl->prev_info, fbo_tex_info, fbo_tex_info_cnt);
 
          glDrawArrays(GL_QUADS, 0, 4);
 
@@ -942,7 +962,7 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
       gl_shader_set_params(prev_rect->img_width, prev_rect->img_height, 
             prev_rect->width, prev_rect->height, 
             gl->vp_width, gl->vp_height, gl->frame_count, 
-            &tex_info, fbo_tex_info, fbo_tex_info_cnt);
+            &tex_info, &gl->prev_info, fbo_tex_info, fbo_tex_info_cnt);
 
       glVertexPointer(2, GL_FLOAT, 2 * sizeof(GLfloat), vertexes_flipped);
       glDrawArrays(GL_QUADS, 0, 4);
@@ -951,6 +971,11 @@ static bool gl_frame(void *data, const void* frame, unsigned width, unsigned hei
    }
 #endif
 
+#if defined(HAVE_XML) || defined(HAVE_CG)
+   memcpy(&gl->prev_info, &tex_info, sizeof(tex_info));
+   gl->tex_index = 1 - gl->tex_index;
+#endif
+
    if (msg)
       gl_render_msg(gl, msg);
 
@@ -970,7 +995,7 @@ static void gl_free(void *data)
    gl_shader_deinit();
    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-   glDeleteTextures(1, &gl->texture);
+   glDeleteTextures(2, gl->texture);
 
 #ifdef HAVE_FBO
    if (gl->fbo_inited)
@@ -987,19 +1012,26 @@ 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");
-#ifdef _WIN32
+#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) 
@@ -1017,6 +1049,10 @@ static void gl_set_nonblock_state(void *data, bool state)
 
 static void* gl_init(const video_info_t *video, const input_driver_t **input, void **input_data)
 {
+#ifdef _WIN32
+   gfx_set_dwm();
+#endif
+
    if (SDL_Init(SDL_INIT_VIDEO) < 0)
       return NULL;
 
@@ -1032,6 +1068,11 @@ static void* gl_init(const video_info_t *video, const input_driver_t **input, vo
    if (!SDL_SetVideoMode(video->width, video->height, g_settings.video.force_16bit ? 16 : 0, SDL_OPENGL | SDL_RESIZABLE | (video->fullscreen ? SDL_FULLSCREEN : 0)))
       return NULL;
 
+   gfx_window_title_reset();
+   char buf[128];
+   if (gfx_window_title(buf, sizeof(buf)))
+      SDL_WM_SetCaption(buf, NULL);
+
    // Remove that ugly mouse :D
    SDL_ShowCursor(SDL_DISABLE);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
@@ -1119,22 +1160,21 @@ static void* gl_init(const video_info_t *video, const input_driver_t **input, vo
    glColor4f(1, 1, 1, 1);
    glClearColor(0, 0, 0, 1);
 
-   char buf[128];
-   if (gfx_window_title(buf, sizeof(buf)))
-      SDL_WM_SetCaption(buf, NULL);
-
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
 
-   glGenTextures(1, &gl->texture);
+   glGenTextures(2, gl->texture);
 
-   glBindTexture(GL_TEXTURE_2D, gl->texture);
+   for (unsigned i = 0; i < 2; i++)
+   {
+      glBindTexture(GL_TEXTURE_2D, gl->texture[i]);
 
-   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
-   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
 
-   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl->tex_filter);
-   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl->tex_filter);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl->tex_filter);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl->tex_filter);
+   }
 
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
@@ -1148,15 +1188,30 @@ static void* gl_init(const video_info_t *video, const input_driver_t **input, vo
    gl->tex_w = 256 * video->input_scale;
    gl->tex_h = 256 * video->input_scale;
 
-   glTexImage2D(GL_TEXTURE_2D,
-         0, GL_RGBA, gl->tex_w, gl->tex_h, 0, gl->texture_type,
-         gl->texture_fmt, NULL);
-
    // Empty buffer that we use to clear out the texture with on res change.
    gl->empty_buf = calloc(gl->base_size, gl->tex_w * gl->tex_h);
 
-   gl->last_width = gl->tex_w;
-   gl->last_height = gl->tex_h;
+   for (unsigned i = 0; i < 2; i++)
+   {
+      glBindTexture(GL_TEXTURE_2D, gl->texture[i]);
+      glTexImage2D(GL_TEXTURE_2D,
+            0, GL_RGBA, gl->tex_w, gl->tex_h, 0, gl->texture_type,
+            gl->texture_fmt, gl->empty_buf ? gl->empty_buf : NULL);
+   }
+   glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
+
+   for (unsigned i = 0; i < 2; i++)
+   {
+      gl->last_width[i] = gl->tex_w;
+      gl->last_height[i] = gl->tex_h;
+   }
+
+   gl->prev_info.tex = gl->texture[1 - gl->tex_index];
+   gl->prev_info.input_size[0] = gl->tex_w;
+   gl->prev_info.tex_size[0] = gl->tex_w;
+   gl->prev_info.input_size[1] = gl->tex_h;
+   gl->prev_info.tex_size[1] = gl->tex_h;
+   memcpy(gl->prev_info.coord, tex_coords, sizeof(tex_coords)); 
 
    // Hook up SDL input driver to get SDL_QUIT events and RESIZE.
    sdl_input_t *sdl_input = input_sdl.init();
@@ -1215,7 +1270,7 @@ static bool gl_xml_shader(void *data, const char *path)
       gl->render_to_tex = false;
       gl->fbo_pass = 0;
 
-      glBindTexture(GL_TEXTURE_2D, gl->texture);
+      glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
    }
 #endif
 

gfx/gl_common.h

@@ -101,9 +101,9 @@ struct gl_fbo_scale
 struct gl_tex_info
 {
    GLuint tex;
-   float input_size[2];
-   float tex_size[2];
-   float coord[8];
+   GLfloat input_size[2];
+   GLfloat tex_size[2];
+   GLfloat coord[8];
 };
 
 // Not legal to cast void* to fn-pointer. Need dirty hack to be compilant.

gfx/sdl.c

@@ -213,6 +213,10 @@ static void sdl_render_msg_32(sdl_video_t *vid, SDL_Surface *buffer, const char
 
 static void* sdl_gfx_init(const video_info_t *video, const input_driver_t **input, void **input_data)
 {
+#ifdef _WIN32
+   gfx_set_dwm();
+#endif
+
    SDL_InitSubSystem(SDL_INIT_VIDEO);
 
    sdl_video_t *vid = calloc(1, sizeof(*vid));

gfx/shader_cg.c

@@ -36,18 +36,15 @@ static const char* stock_cg_program =
       "void main_vertex"
       "("
       "	float4 position	: POSITION,"
-      "	float4 color	: COLOR,"
       "	float2 texCoord : TEXCOORD0,"
       ""
       "  uniform float4x4 modelViewProj,"
       ""
       "	out float4 oPosition : POSITION,"
-      "	out float4 oColor    : COLOR,"
       "	out float2 otexCoord : TEXCOORD0"
       ")"
       "{"
       "	oPosition = mul(modelViewProj, position);"
-      "	oColor = color;"
       "	otexCoord = texCoord;"
       "}"
       ""
@@ -112,6 +109,7 @@ struct cg_program
 
    struct cg_fbo_params fbo[MAX_SHADERS];
    struct cg_fbo_params orig;
+   struct cg_fbo_params prev;
 };
 
 #define FILTER_UNSPEC 0
@@ -148,6 +146,7 @@ void gl_cg_set_params(unsigned width, unsigned height,
       unsigned out_width, unsigned out_height,
       unsigned frame_count,
       const struct gl_tex_info *info,
+      const struct gl_tex_info *prev_info,
       const struct gl_tex_info *fbo_info,
       unsigned fbo_info_cnt)
 {
@@ -169,7 +168,6 @@ void gl_cg_set_params(unsigned width, unsigned height,
       if (param)
       {
          cgGLSetTextureParameter(param, info->tex);
-         //fprintf(stderr, "ORIGtex = (%d) %d\n", cgGLGetTextureParameter(param), cgGLGetTextureEnum(param) - GL_TEXTURE0);
          cgGLEnableTextureParameter(param);
       }
 
@@ -183,6 +181,24 @@ void gl_cg_set_params(unsigned width, unsigned height,
          cgGLEnableClientState(prg[active_index].orig.coord);
       }
 
+      // Set prev texture
+      param = prg[active_index].prev.tex;
+      if (param)
+      {
+         cgGLSetTextureParameter(param, prev_info->tex);
+         cgGLEnableTextureParameter(param);
+      }
+
+      set_param_2f(prg[active_index].prev.vid_size_v, prev_info->input_size[0], prev_info->input_size[1]);
+      set_param_2f(prg[active_index].prev.vid_size_f, prev_info->input_size[0], prev_info->input_size[1]);
+      set_param_2f(prg[active_index].prev.tex_size_v, prev_info->tex_size[0], prev_info->tex_size[1]);
+      set_param_2f(prg[active_index].prev.tex_size_f, prev_info->tex_size[0], prev_info->tex_size[1]);
+      if (prg[active_index].prev.coord)
+      {
+         cgGLSetParameterPointer(prg[active_index].prev.coord, 2, GL_FLOAT, 0, prev_info->coord);
+         cgGLEnableClientState(prg[active_index].prev.coord);
+      }
+
       // Set lookup textures.
       for (unsigned i = 0; i < lut_textures_num; i++)
       {
@@ -191,7 +207,6 @@ void gl_cg_set_params(unsigned width, unsigned height,
          {
             cgGLSetTextureParameter(param, lut_textures[i]);
             cgGLEnableTextureParameter(param);
-            //fprintf(stderr, "LUTtex = (%d) %d\n", cgGLGetTextureParameter(param), cgGLGetTextureEnum(param) - GL_TEXTURE0);
          }
       }
       
@@ -273,16 +288,31 @@ static bool load_plain(const char *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;
+
    prg[0].fprg = cgCreateProgram(cgCtx, CG_SOURCE, stock_cg_program, cgFProf, "main_fragment", 0);
    prg[0].vprg = cgCreateProgram(cgCtx, CG_SOURCE, stock_cg_program, cgVProf, "main_vertex", 0);
 
+   list = cgGetLastListing(cgCtx);
+   if (list)
+      listing[0] = strdup(list);
+
    prg[1].fprg = cgCreateProgramFromFile(cgCtx, CG_SOURCE, path, cgFProf, "main_fragment", 0);
    prg[1].vprg = cgCreateProgramFromFile(cgCtx, CG_SOURCE, path, cgVProf, "main_vertex", 0);
 
+   list = cgGetLastListing(cgCtx);
+   if (list)
+      listing[1] = strdup(list);
+
    if (strlen(g_settings.video.second_pass_shader) > 0)
    {
       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);
+
+      list = cgGetLastListing(cgCtx);
+      if (list)
+         listing[2] = strdup(list);
       cg_shader_num = 2;
    }
    else
@@ -291,13 +321,15 @@ static bool load_plain(const char *path)
       cg_shader_num = 1;
    }
 
-   for (int i = 0; i < cg_shader_num + 1; i++)
+   for (unsigned i = 0; i <= cg_shader_num; i++)
    {
       if (!prg[i].fprg || !prg[i].vprg)
       {
          CGerror err = cgGetError();
          SSNES_ERR("CG error: %s\n", cgGetErrorString(err));
-         return false;
+         if (listing[i])
+            SSNES_ERR("%s\n", listing[i]);
+         goto error;
       }
 
       cgGLLoadProgram(prg[i].fprg);
@@ -305,6 +337,14 @@ static bool load_plain(const char *path)
    }
 
    return true;
+
+error:
+   for (unsigned i = 0; i < 3; i++)
+   {
+      if (listing[i])
+         free(listing[i]);
+   }
+   return false;
 }
 
 #define print_buf(buf, ...) snprintf(buf, sizeof(buf), __VA_ARGS__)
@@ -802,8 +842,11 @@ static bool load_preset(const char *path)
 
       if (!prog->fprg || !prog->vprg)
       {
+         const char *listing = cgGetLastListing(cgCtx);
          CGerror err = cgGetError();
          SSNES_ERR("CG error: %s\n", cgGetErrorString(err));
+         if (listing)
+            SSNES_ERR("%s\n", listing);
          goto error;
       }
 
@@ -878,7 +921,7 @@ bool gl_cg_init(const char *path)
    if (prg[0].mvp)
       cgGLSetStateMatrixParameter(prg[0].mvp, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
 
-   for (unsigned i = 1; i < cg_shader_num + 1; i++)
+   for (unsigned i = 1; i <= cg_shader_num; i++)
    {
       cgGLBindProgram(prg[i].fprg);
       cgGLBindProgram(prg[i].vprg);
@@ -902,6 +945,13 @@ bool gl_cg_init(const char *path)
       prg[i].orig.tex_size_f = cgGetNamedParameter(prg[i].fprg, "ORIG.texture_size");
       prg[i].orig.coord = cgGetNamedParameter(prg[i].vprg, "ORIG.tex_coord");
 
+      prg[i].prev.tex = cgGetNamedParameter(prg[i].fprg, "PREV.texture");
+      prg[i].prev.vid_size_v = cgGetNamedParameter(prg[i].vprg, "PREV.video_size");
+      prg[i].prev.vid_size_f = cgGetNamedParameter(prg[i].fprg, "PREV.video_size");
+      prg[i].prev.tex_size_v = cgGetNamedParameter(prg[i].vprg, "PREV.texture_size");
+      prg[i].prev.tex_size_f = cgGetNamedParameter(prg[i].fprg, "PREV.texture_size");
+      prg[i].prev.coord = cgGetNamedParameter(prg[i].vprg, "PREV.tex_coord");
+
       for (unsigned j = 0; j < i - 1; j++)
       {
          char attr_buf[64];

gfx/shader_cg.h

@@ -33,6 +33,7 @@ void gl_cg_set_params(unsigned width, unsigned height,
       unsigned out_width, unsigned out_height,
       unsigned frame_count,
       const struct gl_tex_info *info,
+      const struct gl_tex_info *prev_info,
       const struct gl_tex_info *fbo_info, unsigned fbo_info_cnt);
 
 void gl_cg_use(unsigned index);

gfx/shader_glsl.c

@@ -712,8 +712,8 @@ error:
 
 static void print_shader_log(GLuint obj)
 {
-   int info_len = 0;
-   int max_len;
+   GLint info_len = 0;
+   GLint max_len;
 
    pglGetShaderiv(obj, GL_INFO_LOG_LENGTH, &max_len);
 
@@ -726,8 +726,8 @@ static void print_shader_log(GLuint obj)
 
 static void print_linker_log(GLuint obj)
 {
-   int info_len = 0;
-   int max_len;
+   GLint info_len = 0;
+   GLint max_len;
 
    pglGetProgramiv(obj, GL_INFO_LOG_LENGTH, &max_len);
 
@@ -1005,8 +1005,16 @@ void gl_glsl_set_params(unsigned width, unsigned height,
       unsigned out_width, unsigned out_height,
       unsigned frame_count,
       const struct gl_tex_info *info, 
+      const struct gl_tex_info *prev_info, 
       const struct gl_tex_info *fbo_info, unsigned fbo_info_cnt)
 {
+   // We enforce a certain layout for our various texture types in the texunits.
+   // Unit 0: Regular SNES frame (rubyTexture).
+   // Unit 1-A: LUT textures.
+   // Unit A+1: Previous texture.
+   // Unit A+2: Original texture.
+   // Unit A+3-B: FBO textures.
+
    if (glsl_enable && gl_program[active_index] > 0)
    {
       GLint location;
@@ -1032,15 +1040,34 @@ void gl_glsl_set_params(unsigned width, unsigned height,
          pglUniform1i(location, i + 1);
       }
 
+      // Set previous texture.
+      pglActiveTexture(GL_TEXTURE0 + gl_teximage_cnt + 1);
+      glBindTexture(GL_TEXTURE_2D, prev_info->tex);
+      location = pglGetUniformLocation(gl_program[active_index], "rubyPrevTexture");
+      pglUniform1i(location, gl_teximage_cnt + 1);
+
+      location = pglGetUniformLocation(gl_program[active_index], "rubyPrevTextureSize");
+      pglUniform2fv(location, 1, prev_info->tex_size);
+      location = pglGetUniformLocation(gl_program[active_index], "rubyPrevInputSize");
+      pglUniform2fv(location, 1, prev_info->input_size);
+
+      // Pass texture coordinates.
+      location = pglGetAttribLocation(gl_program[active_index], "rubyPrevTexCoord");
+      if (location >= 0)
+      {
+         pglEnableVertexAttribArray(location);
+         pglVertexAttribPointer(location, 2, GL_FLOAT, GL_FALSE, 0, prev_info->coord);
+      }
+
       // Set original texture unless we're in first pass (pointless).
       if (active_index > 1)
       {
          // Bind original texture.
-         pglActiveTexture(GL_TEXTURE0 + gl_teximage_cnt + 1);
+         pglActiveTexture(GL_TEXTURE0 + gl_teximage_cnt + 2);
          glBindTexture(GL_TEXTURE_2D, info->tex);
 
          location = pglGetUniformLocation(gl_program[active_index], "rubyOrigTexture");
-         pglUniform1i(location, gl_teximage_cnt + 1);
+         pglUniform1i(location, gl_teximage_cnt + 2);
 
          location = pglGetUniformLocation(gl_program[active_index], "rubyOrigTextureSize");
          pglUniform2fv(location, 1, info->tex_size);
@@ -1055,7 +1082,7 @@ void gl_glsl_set_params(unsigned width, unsigned height,
             pglVertexAttribPointer(location, 2, GL_FLOAT, GL_FALSE, 0, info->coord);
          }
 
-         GLuint base_tex = GL_TEXTURE0 + gl_teximage_cnt + 2;
+         GLuint base_tex = GL_TEXTURE0 + gl_teximage_cnt + 3;
 
          // Bind new texture in the chain.
          if (fbo_info_cnt > 0)
@@ -1093,14 +1120,15 @@ void gl_glsl_set_params(unsigned width, unsigned height,
       else
       {
          // First pass, so unbind everything to avoid collitions.
-         pglActiveTexture(GL_TEXTURE0 + gl_teximage_cnt + 1);
+         // Unbind ORIG.
+         pglActiveTexture(GL_TEXTURE0 + gl_teximage_cnt + 2);
          glBindTexture(GL_TEXTURE_2D, 0);
 
-         GLuint base_tex = GL_TEXTURE0 + gl_teximage_cnt + 2;
+         GLuint base_tex = GL_TEXTURE0 + gl_teximage_cnt + 3;
          // Unbind any lurking FBO passes.
          // Rendering to a texture that is bound to a texture unit
          // sounds very shaky ... ;)
-         for (int i = 0; i < gl_num_programs; i++)
+         for (unsigned i = 0; i < gl_num_programs; i++)
          {
             pglActiveTexture(GL_TEXTURE0 + base_tex + i);
             glBindTexture(GL_TEXTURE_2D, 0);

gfx/shader_glsl.h

@@ -33,6 +33,7 @@ void gl_glsl_set_params(unsigned width, unsigned height,
       unsigned out_width, unsigned out_height,
       unsigned frame_counter,
       const struct gl_tex_info *info, 
+      const struct gl_tex_info *prev_info,
       const struct gl_tex_info *fbo_info, unsigned fbo_info_cnt);
 
 void gl_glsl_use(unsigned index);

gfx/snes_state.c

@@ -31,7 +31,6 @@ struct snes_tracker_internal
    char id[64];
 
    bool is_input;
-   unsigned input_slot;
    const uint16_t *input_ptr;
    const uint8_t *ptr;
 #ifdef HAVE_PYTHON
@@ -118,12 +117,10 @@ snes_tracker_t* snes_tracker_init(const struct snes_tracker_info *info)
             break;
          case SSNES_STATE_INPUT_SLOT1:
             tracker->info[i].input_ptr = &tracker->input_state[0];
-            tracker->info[i].input_slot = 0;
             tracker->info[i].is_input = true;
             break;
          case SSNES_STATE_INPUT_SLOT2:
             tracker->info[i].input_ptr = &tracker->input_state[1];
-            tracker->info[i].input_slot = 1;
             tracker->info[i].is_input = true;
             break;
 
@@ -144,7 +141,7 @@ void snes_tracker_free(snes_tracker_t *tracker)
    free(tracker);
 }
 
-#define fetch() ((info->is_input ? info->input_ptr[info->input_slot] : info->ptr[info->addr]) & info->mask)
+#define fetch() ((info->is_input ? *info->input_ptr : info->ptr[info->addr]) & info->mask)
 
 static void update_element(
       struct snes_tracker_uniform *uniform,

movie.c

@@ -107,18 +107,6 @@ struct bsv_movie
 #define CRC_INDEX 2
 #define STATE_SIZE_INDEX 3
 
-static inline uint8_t is_little_endian(void)
-{
-   union
-   {
-      uint16_t u16;
-      uint8_t u8[2];
-   } u;
-
-   u.u16 = 1;
-   return u.u8[0];
-}
-
 // Convert to big-endian if needed
 static inline uint32_t swap_if_big32(uint32_t val)
 {

netplay.c

@@ -96,10 +96,7 @@ struct netplay
 void input_poll_net(void)
 {
    if (!netplay_should_skip(g_extern.netplay) && netplay_can_poll(g_extern.netplay))
-   {
-      netplay_callbacks(g_extern.netplay)->poll_cb();
       netplay_poll(g_extern.netplay);
-   }
 }
 
 void video_frame_net(const uint16_t *data, unsigned width, unsigned height)
@@ -243,7 +240,7 @@ static bool init_socket(netplay_t *handle, const char *server, uint16_t port)
 {
 #ifdef _WIN32
    WSADATA wsaData;
-   if (WSAStartup(MAKEWORD(2,2), &wsaData) != 0)
+   if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
    {
       WSACleanup();
       return false;
@@ -470,7 +467,7 @@ static bool get_self_input_state(netplay_t *handle)
    if (handle->frame_count > 0) // First frame we always give zero input since relying on input from first frame screws up when we use -F 0.
    {
       snes_input_state_t cb = handle->cbs.state_cb;
-      for (int i = 0; i <= 11; i++)
+      for (unsigned i = 0; i <= 11; i++)
       {
          int16_t tmp = cb(g_settings.input.netplay_client_swap_input ? 0 : !handle->port, SNES_DEVICE_JOYPAD, 0, i);
          state |= tmp ? 1 << i : 0;
@@ -659,6 +656,8 @@ void netplay_pre_frame(netplay_t *handle)
 {
    psnes_serialize(handle->buffer[handle->self_ptr].state, handle->state_size);
    handle->can_poll = true;
+
+   input_poll_net();
 }
 
 // Here we check if we have new input and replay from recorded input.

netplay.h

@@ -34,7 +34,6 @@ struct snes_callbacks
 {
    snes_video_refresh_t frame_cb;
    snes_audio_sample_t sample_cb;
-   snes_input_poll_t poll_cb;
    snes_input_state_t state_cb;
 };
 

qb/config.libs.sh

@@ -3,6 +3,12 @@
 check_switch_c C99 -std=gnu99
 check_critical C99 "Cannot find C99 compatible compiler."
 
+if [ "$OS" = BSD ]; then
+   DYLIB=-lc
+else
+   DYLIB=-ldl
+fi
+
 if [ "$HAVE_DYNAMIC" = "yes" ] && [ "$HAVE_CONFIGFILE" = "no" ]; then
    echo "Cannot have dynamic loading of libsnes and no configfile support."
    echo "Dynamic loading requires config file support."
@@ -10,16 +16,18 @@ if [ "$HAVE_DYNAMIC" = "yes" ] && [ "$HAVE_CONFIGFILE" = "no" ]; then
 fi
 
 if [ $HAVE_DYNAMIC != yes ]; then
-   check_lib_cxx SNES $LIBSNES snes_init -ldl
+   check_lib_cxx SNES $LIBSNES snes_init $DYLIB
    check_critical SNES "Cannot find libsnes."
    add_define_make libsnes $LIBSNES
 fi
 
-check_lib DYLIB -ldl dlopen
+check_lib DYLIB $DYLIB dlopen
 check_lib NETPLAY -lc socket
 
-check_lib ALSA -lasound snd_pcm_open
+check_pkgconf ALSA alsa
 check_header OSS sys/soundcard.h
+check_header OSS_BSD soundcard.h
+check_lib OSS_LIB -lossaudio
 
 if [ "$OS" = "Darwin" ]; then
    check_lib AL "-framework OpenAL" alcOpenDevice
@@ -34,12 +42,19 @@ else
 fi
 
 check_pkgconf RSOUND rsound 1.1
-check_lib ROAR -lroar roar_vs_new
+check_pkgconf ROAR libroar
 check_pkgconf JACK jack 0.120.1
 check_pkgconf PULSE libpulse
 
+check_lib COREAUDIO "-framework AudioUnit" AudioUnitInitialize
+
 check_pkgconf SDL sdl 1.2.10
-check_critical SDL "Cannot find SDL library."
+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_lib CG -lCg cgCreateContext
 check_pkgconf XML libxml-2.0
@@ -48,26 +63,27 @@ check_pkgconf SDL_IMAGE SDL_image
 if [ $HAVE_FFMPEG != no ]; then
    check_pkgconf AVCODEC libavcodec
    check_pkgconf AVFORMAT libavformat
-   check_pkgconf AVCORE libavcore
    check_pkgconf AVUTIL libavutil
    check_pkgconf SWSCALE libswscale
 
-   ( [ $HAVE_FFMPEG = auto ] && ( [ $HAVE_AVCODEC = no ] || [ $HAVE_AVFORMAT = no ] || [ $HAVE_AVCORE = no ] || [ $HAVE_AVUTIL = no ] || [ $HAVE_SWSCALE = no ] ) && HAVE_FFMPEG=no ) || HAVE_FFMPEG=yes
+   ( [ $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
 
-check_lib DYNAMIC -ldl dlopen
+check_lib DYNAMIC $DYLIB dlopen
 
 check_pkgconf FREETYPE freetype2
-check_lib XVIDEO -lXv XvShmCreateImage
+check_pkgconf XVIDEO xv
 
 check_lib STRL -lc strlcpy
 
 check_pkgconf PYTHON python3
 
+add_define_make OS $OS
+
 # Creates config.mk and config.h.
-VARS="ALSA OSS AL RSOUND ROAR JACK PULSE SDL DYLIB CG XML SDL_IMAGE DYNAMIC FFMPEG AVCODEC AVFORMAT AVCORE 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 SRC CONFIGFILE FREETYPE XVIDEO NETPLAY FBO STRL PYTHON"
 create_config_make config.mk $VARS
 create_config_header config.h $VARS
 

qb/config.params.sh

@@ -1,7 +1,7 @@
 . qb/qb.params.sh
 
 PACKAGE_NAME=ssnes
-PACKAGE_VERSION=0.5.2
+PACKAGE_VERSION=0.7
 
 # Adds a command line opt to ./configure --help
 # $1: Variable (HAVE_ALSA, HAVE_OSS, etc)   
@@ -23,6 +23,7 @@ add_command_line_enable RSOUND "Enable RSound support" auto
 add_command_line_enable ROAR "Enable RoarAudio support" auto
 add_command_line_enable AL "Enable OpenAL support" auto
 add_command_line_enable JACK "Enable JACK support" auto
+add_command_line_enable COREAUDIO "Enable CoreAudio support" auto
 add_command_line_enable PULSE "Enable PulseAudio support" auto
 add_command_line_enable FREETYPE "Enable FreeType support" auto
 add_command_line_enable XVIDEO "Enable XVideo support" auto

qb/qb.comp.sh

@@ -1,24 +1,25 @@
-. qb/conf.comp.sh
+. qb/config.comp.sh
 
 TEMP_C=.tmp.c
 TEMP_CXX=.tmp.cxx
 TEMP_EXE=.tmp
 
-echo -n "Checking operating system ... "
+ECHOBUF="Checking operating system ... "
 OS="Win32" # whatever ;D
 unamestr="`uname -a`"
-if [ ! -z "`echo $unamestr | grep -i Linux`" ]; then
+if [ ! -z "`echo "$unamestr" | grep -i Linux`" ]; then
    OS="Linux"
-elif [ ! -z "`echo $unamestr | grep -i Darwin`" ]; then
+elif [ ! -z "`echo "$unamestr" | grep -i Darwin`" ]; then
    OS="Darwin"
-elif [ ! -z "`echo $unamestr | grep -i BSD`" ]; then
+elif [ ! -z "`echo "$unamestr" | grep -i BSD`" ]; then
    OS="BSD"
-elif [ ! -z "`echo $unamestr | grep -i NT`" ]; then
+elif [ ! -z "`echo "$unamestr" | grep -i MINGW32`" ]; then
+   OS="MinGW"
+elif [ ! -z "`echo "$unamestr" | grep -i NT`" ]; then
    OS="Cygwin"
 fi
 
-echo $OS
-
+echo $ECHOBUF $OS
 
 # Checking for working C compiler
 if [ "$USE_LANG_C" = yes ]; then
@@ -31,12 +32,12 @@ if [ "$USE_LANG_C" = yes ]; then
       exit 1
    fi
 
-   echo -n "Checking if $CC is a suitable compiler ... "
+   ECHOBUF="Checking if $CC is a suitable compiler ..."
    answer=no
    echo "#include <stdio.h>" > $TEMP_C
    echo "int main(void) { puts(\"Hai world!\"); return 0; }" >> $TEMP_C
    $CC -o $TEMP_EXE $TEMP_C 2>/dev/null >/dev/null && answer=yes
-   echo $answer
+   echo $ECHOBUF $answer
 
    rm -rf $TEMP_C $TEMP_EXE
 
@@ -54,12 +55,12 @@ if [ "$USE_LANG_CXX" = "yes" ]; then
       exit 1
    fi
 
-   echo -n "Checking if $CXX is a suitable compiler ... "
+   ECHOBUF="Checking if $CXX is a suitable compiler ..."
    answer=no
    echo "#include <iostream>" > $TEMP_CXX
    echo "int main() { std::cout << \"Hai guise\" << std::endl; return 0; }" >> $TEMP_CXX
    $CXX -o $TEMP_EXE $TEMP_CXX 2>/dev/null >/dev/null && answer=yes
-   echo $answer
+   echo $ECHOBUF $answer
 
    rm -rf $TEMP_CXX $TEMP_EXE
 

qb/qb.libs.sh

@@ -41,9 +41,13 @@ check_lib()
    eval tmpval=\$$tmpval
    [ "$tmpval" = "no" ] && return 0
 
-   echo -n "Checking function $3 in $2 ... "
-   echo "void $3(void); int main(void) { $3(); return 0; }" > $TEMP_C
-
+   if [ -z "$3" ]; then
+      ECHOBUF="Checking existence of $2 ..."
+      echo "int main(void) { return 0; }" > $TEMP_C
+   else
+      ECHOBUF="Checking function $3 in $2 ..."
+      echo "void $3(void); int main(void) { $3(); return 0; }" > $TEMP_C
+   fi
 
    eval HAVE_$1=no
    answer=no
@@ -52,9 +56,9 @@ check_lib()
 
    $CC -o $TEMP_EXE $TEMP_C $INCLUDE_DIRS $LIBRARY_DIRS $extralibs $CFLAGS $LDFLAGS $2 2>/dev/null >/dev/null && answer=yes && eval HAVE_$1=yes
 
-   echo $answer
+   echo $ECHOBUF $answer
 
-   rm -rf $TEMP_C $TEMP_EXE
+   rm -f $TEMP_C $TEMP_EXE
    if [ "$tmpval" = "yes" ] && [ "$answer" = "no" ]; then
       echo "Forced to build with library $2, but cannot locate. Exiting ..."
       exit 1
@@ -67,8 +71,13 @@ check_lib_cxx()
    eval tmpval=\$$tmpval
    [ "$tmpval" = "no" ] && return 0
 
-   echo -n "Checking function $3 in $2 ... "
-   echo "extern \"C\" { void $3(void); } int main() { $3(); }" > $TEMP_CXX
+   if [ -z "$3" ]; then
+      ECHOBUF="Checking existence of $2 ..."
+      echo "int main() { return 0; }" > $TEMP_CXX
+   else
+      ECHOBUF="Checking function $3 in $2 ..."
+      echo "extern \"C\" { void $3(void); } int main() { $3(); }" > $TEMP_CXX
+   fi
 
    eval HAVE_$1=no
    answer=no
@@ -77,25 +86,55 @@ check_lib_cxx()
 
    $CXX -o $TEMP_EXE $TEMP_CXX $INCLUDE_DIRS $LIBRARY_DIRS $extralibs $CFLAGS $LDFLAGS $2 2>/dev/null >/dev/null && answer=yes && eval HAVE_$1=yes
 
-   echo $answer
+   echo $ECHOBUF $answer
 
-   rm -rf $TEMP_CXX $TEMP_EXE
+   rm -f $TEMP_CXX $TEMP_EXE
    if [ "$tmpval" = "yes" ] && [ "$answer" = "no" ]; then
       echo "Forced to build with library $2, but cannot locate. Exiting ..."
       exit 1
    fi
 }
 
+check_code_c()
+{
+   tmpval="HAVE_$1"
+   eval tmpval=\$$tmpval
+   [ "$tmpval" = "no" ] && return 0
+
+   ECHOBUF="Checking C code snippet \"$3\" ..."
+   eval HAVE_$1=no
+   answer=no
+   $CC -o $TEMP_EXE $TEMP_C $INCLUDE_DIRS $LIBRARY_DIRS $2 $CFLAGS $LDFLAGS 2>/dev/null >/dev/null && answer=yes && eval HAVE_$1=yes
+
+   echo $ECHOBUF $answer
+   rm -f $TEMP_C $TEMP_EXE
+}
+
+check_code_cxx()
+{
+   tmpval="HAVE_$1"
+   eval tmpval=\$$tmpval
+   [ "$tmpval" = "no" ] && return 0
+
+   ECHOBUF="Checking C++ code snippet \"$3\" ..."
+   eval HAVE_$1=no
+   answer=no
+   $CXX -o $TEMP_EXE $TEMP_CXX $INCLUDE_DIRS $LIBRARY_DIRS $2 $CXXFLAGS $LDFLAGS 2>/dev/null >/dev/null && answer=yes && eval HAVE_$1=yes
+
+   echo $ECHOBUF $answer
+   rm -f $TEMP_CXX $TEMP_EXE
+}
+
 locate_pkg_conf()
 {
-   echo -n "Checking for pkg-config ... "
+   ECHOBUF="Checking for pkg-config ... "
    PKG_CONF_PATH="`which pkg-config | grep ^/ | head -n1`"
    if [ -z $PKG_CONF_PATH ]; then
       echo "not found"
       echo "Cannot locate pkg-config. Exiting ..."
       exit 1
    fi
-   echo "$PKG_CONF_PATH"
+   echo $ECHOBUF $PKG_CONF_PATH
 }
 
 check_pkgconf()
@@ -106,16 +145,16 @@ check_pkgconf()
    eval tmpval=\$$tmpval
    [ "$tmpval" = "no" ] && return 0
 
-   echo -n "Checking presence of package $2"
+   ECHOBUF="Checking presence of package $2"
    eval HAVE_$1=no
    eval $1_CFLAGS=""
    eval $1_LIBS=""
    answer=no
    minver=0.0
-   [ ! -z $3 ] && minver=$3 && echo -n " with minimum version $minver"
-   echo -n " ... "
+   [ ! -z $3 ] && minver=$3 && ECHOBUF="$ECHOBUF with minimum version $minver"
+   ECHOBUF="$ECHOBUF ... "
    pkg-config --atleast-version=$minver "$2" && eval HAVE_$1=yes && eval $1_CFLAGS='"`pkg-config $2 --cflags`"' && eval $1_LIBS='"`pkg-config $2 --libs`"' && answer=yes
-   echo $answer
+   echo $ECHOBUF $answer
 
    PKG_CONF_USED="$PKG_CONF_USED $1"
 
@@ -131,7 +170,7 @@ check_header()
    eval tmpval=\$$tmpval
    [ "$tmpval" = "no" ] && return 0
 
-   echo -n "Checking presence of header file $2 ... "
+   ECHOBUF="Checking presence of header file $2 ..."
    echo "#include<$2>" > $TEMP_C
    echo "int main(void) { return 0; }" >> $TEMP_C
    eval HAVE_$1=no
@@ -139,7 +178,7 @@ check_header()
 
    $CC -o $TEMP_EXE $TEMP_C $INCLUDE_DIRS 2>/dev/null >/dev/null && answer=yes && eval HAVE_$1=yes
 
-   echo $answer
+   echo $ECHOBUF $answer
 
    rm -rf $TEMP_C $TEMP_EXE
    if [ "$tmpval" = "yes" ] && [ "$answer" = "no" ]; then 
@@ -150,7 +189,7 @@ check_header()
 
 check_switch_c()
 {
-   echo -n "Checking for availability of switch $2 in $CC ... "
+   ECHOBUF="Checking for availability of switch $2 in $CC ..."
    if [ -z "$CC" ]; then
       echo "No C compiler, cannot check ..."
       exit 1
@@ -160,14 +199,14 @@ check_switch_c()
    answer=no
    $CC -o $TEMP_EXE $TEMP_C $2 2>/dev/null >/dev/null && answer=yes && eval HAVE_$1=yes
 
-   echo $answer
+   echo $ECHOBUF $answer
 
    rm -rf $TEMP_C $TEMP_EXE
 }
 
 check_switch_cxx()
 {
-   echo -n "Checking for availability of switch $2 in $CXX ... "
+   ECHOBUF="Checking for availability of switch $2 in $CXX ... "
    if [ -z "$CXX" ]; then
       echo "No C++ compiler, cannot check ..."
       exit 1
@@ -177,7 +216,7 @@ check_switch_cxx()
    answer=no
    $CXX -o $TEMP_EXE $TEMP_CXX $2 2>/dev/null >/dev/null && answer=yes && eval HAVE_$1=yes
 
-   echo $answer
+   echo $ECHOBUF $answer
 
    rm -rf $TEMP_CXX $TEMP_EXE
 }
@@ -207,7 +246,7 @@ create_config_header()
 
    echo "Creating config header: $outfile"
 
-   name="`echo __$outfile | sed 's|[\./]|_|g' | tr '[a-z]' '[A-Z]'`"
+   name="`echo QB_${outfile}__ | sed 's|[\./]|_|g' | tr '[a-z]' '[A-Z]'`"
    echo "#ifndef $name" > "$outfile"
    echo "#define $name" >> "$outfile"
    echo "" >> "$outfile"
@@ -251,7 +290,6 @@ output_define_make()
 
 create_config_make()
 {
-
    outfile="$1"
    shift
 

qb/qb.params.sh

@@ -64,8 +64,7 @@ print_sub_opt()
    lowertext="`echo $arg1 | tr '[A-Z]' '[a-z]'`"
 
    if [ "$arg3" = "auto" ]; then
-      echo -n "--enable-$lowertext: "
-      echo $arg2
+      echo "--enable-$lowertext: $arg2"
       echo "--disable-$lowertext"
    elif [ "$arg3" = "yes" ]; then
       echo "--disable-$lowertext: $arg2"
@@ -103,8 +102,9 @@ parse_input()
             ;;
 
          --enable-*)
-            enable=`echo $1 | sed 's|^--enable-||'`
-            if [ -z "`echo $COMMAND_LINE_OPTS_ENABLE | grep -i $enable`" ]; then
+            tmp="$1"
+            enable="${tmp#--enable-}"
+            if [ -z "`echo $COMMAND_LINE_OPTS_ENABLE | grep -i -- $enable`" ]; then
                print_help
                exit 1
             fi
@@ -112,8 +112,9 @@ parse_input()
             ;;
 
          --disable-*)
-            disable=`echo $1 | sed 's|^--disable-||'`
-            if [ -z "`echo $COMMAND_LINE_OPTS_ENABLE | grep -i $disable`" ]; then
+            tmp="$1"
+            disable="${tmp#--disable-}"
+            if [ -z "`echo $COMMAND_LINE_OPTS_ENABLE | grep -i -- $disable`" ]; then
                print_help
                exit 1
             fi
@@ -121,9 +122,11 @@ parse_input()
             ;;
 
          --with-*)
-            arg="`echo $1 | sed 's|^--with-\S\S*=||'`"
-            with=`echo $1 | sed 's|^--with-\(\S\S*\)=.*$|\1|'`
-            if [ -z "`echo $COMMAND_LINE_OPTS_STRINGS | grep -i $with`" ]; then
+            tmp="$1"
+            arg="${tmp#--with-*=}"
+            tmp="${tmp#--with-}"
+            with="${tmp%%=*}"
+            if [ -z "`echo $COMMAND_LINE_OPTS_STRINGS | grep -i -- $with`" ]; then
                print_help
                exit 1
             fi

record/ffemu.c

@@ -2,18 +2,21 @@
 #include <libavutil/mathematics.h>
 #include <libavutil/avutil.h>
 #include <libavutil/avstring.h>
+#include <libavutil/opt.h>
 #include <libavformat/avformat.h>
 #include <libswscale/swscale.h>
+#include <libavutil/avconfig.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <assert.h>
 #include <stdlib.h>
 #include <stdbool.h>
 #include "ffemu.h"
+#include "fifo_buffer.h"
+#include "SDL_thread.h"
 
 struct video_info
 {
-   bool enabled;
    AVCodecContext *codec;
 
    AVFrame *conv_frame;
@@ -23,13 +26,16 @@ struct video_info
    uint8_t *outbuf;
    size_t outbuf_size;
 
+   int fmt;
+   int pix_size;
+
    AVFormatContext *format;
 
+   struct SwsContext *sws_ctx;
 } video;
 
 struct audio_info
 {
-   bool enabled;
    AVCodecContext *codec;
 
    int16_t *buffer;
@@ -55,158 +61,185 @@ struct ffemu
    struct muxer_info muxer;
    
    struct ffemu_params params;
+
+   SDL_cond *cond;
+   SDL_mutex *cond_lock;
+   SDL_mutex *lock;
+   fifo_buffer_t *audio_fifo;
+   fifo_buffer_t *video_fifo;
+   fifo_buffer_t *attr_fifo;
+   SDL_Thread *thread;
+   volatile bool alive;
+   volatile bool can_sleep;
 };
 
-// Currently hardcoded atm. :)
-static int map_audio_codec(ffemu_audio_codec codec)
+static bool init_audio(struct audio_info *audio, struct ffemu_params *param)
 {
-   (void)codec;
-   return CODEC_ID_VORBIS;
-}
-
-// Currently hardcoded atm. :)
-static int map_video_codec(ffemu_video_codec codec)
-{
-   (void)codec;
-   return CODEC_ID_H264;
-}
-
-static int init_audio(struct audio_info *audio, struct ffemu_params *param)
-{
-   AVCodec *codec = avcodec_find_encoder(map_audio_codec(param->acodec));
+   AVCodec *codec = avcodec_find_encoder(CODEC_ID_FLAC);
    if (!codec)
-      return -1;
+      return false;
 
    audio->codec = avcodec_alloc_context();
-
    avcodec_get_context_defaults(audio->codec);
 
-   // Hardcode this atm.
-   audio->codec->global_quality = 100000;
-   audio->codec->flags |= CODEC_FLAG_QSCALE;
    audio->codec->sample_rate = param->samplerate;
    audio->codec->time_base = (AVRational) { 1, param->samplerate };
    audio->codec->channels = param->channels;
    audio->codec->sample_fmt = AV_SAMPLE_FMT_S16;
    if (avcodec_open(audio->codec, codec) != 0)
-      return -1;
-
+      return false;
 
    audio->buffer = av_malloc(audio->codec->frame_size * param->channels * sizeof(int16_t));
    if (!audio->buffer)
-      return -1;
+      return false;
 
-   audio->outbuf_size = 50000;
+   audio->outbuf_size = 2000000;
    audio->outbuf = av_malloc(audio->outbuf_size);
    if (!audio->outbuf)
-      return -1;
+      return false;
 
-   return 0;
+   return true;
 }
 
-// Hardcode.
-static void init_x264_param(AVCodecContext *c)
+static bool init_video(struct video_info *video, struct ffemu_params *param)
 {
-   c->coder_type = 1;  // coder = 1
-   c->flags|=CODEC_FLAG_LOOP_FILTER;   // flags=+loop
-   c->me_cmp|= 1;  // cmp=+chroma, where CHROMA = 1
-   c->partitions|=X264_PART_I8X8+X264_PART_I4X4+X264_PART_P8X8+X264_PART_B8X8; // partitions=+parti8x8+parti4x4+partp8x8+partb8x8
-   c->me_method=ME_HEX;    // me_method=hex
-   c->me_subpel_quality = 7;   // subq=7
-   c->me_range = 16;   // me_range=16
-   c->gop_size = 250;  // g=250
-   c->keyint_min = 25; // keyint_min=25
-   c->scenechange_threshold = 40;  // sc_threshold=40
-   c->i_quant_factor = 0.71; // i_qfactor=0.71
-   c->b_frame_strategy = 1;  // b_strategy=1
-   c->qcompress = 0.6; // qcomp=0.6
-   c->qmin = 10;   // qmin=10
-   c->qmax = 51;   // qmax=51
-   c->max_qdiff = 4;   // qdiff=4
-   c->max_b_frames = 3;    // bf=3
-   c->refs = 3;    // refs=3
-   c->directpred = 1;  // directpred=1
-   c->trellis = 1; // trellis=1
-   c->flags2|=CODEC_FLAG2_BPYRAMID+CODEC_FLAG2_MIXED_REFS+CODEC_FLAG2_WPRED+CODEC_FLAG2_8X8DCT+CODEC_FLAG2_FASTPSKIP;  // flags2=+bpyramid+mixed_refs+wpred+dct8x8+fastpskip
-   c->weighted_p_pred = 2; // wpredp=2
-
-   // libx264-main.ffpreset preset
-   c->flags2|=CODEC_FLAG2_8X8DCT;
-   c->flags2^=CODEC_FLAG2_8X8DCT;
-}
-
-static int init_video(struct video_info *video, struct ffemu_params *param)
-{
-   AVCodec *codec = avcodec_find_encoder(map_video_codec(param->vcodec));
+   AVCodec *codec = avcodec_find_encoder(CODEC_ID_FFV1);
    if (!codec)
-      return -1;
+      return false;
+
+#if AV_HAVE_BIGENDIAN
+   video->fmt = PIX_FMT_RGB555BE;
+#else
+   video->fmt = PIX_FMT_RGB555LE;
+#endif
+   video->pix_size = sizeof(uint16_t);
+   if (param->rgb32)
+   {
+      video->fmt = PIX_FMT_RGB32;
+      video->pix_size = sizeof(uint32_t);
+   }
 
    video->codec = avcodec_alloc_context();
    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->crf = 25;
-   // Might have to change this later to account for RGB codecs.
-   video->codec->pix_fmt = PIX_FMT_YUV420P;
-   ///// Is this element in all recent ffmpeg versions?
-   video->codec->thread_count = 4;
-   /////
+   video->codec->pix_fmt = PIX_FMT_RGB32;
    video->codec->sample_aspect_ratio = av_d2q(param->aspect_ratio * param->out_height / param->out_width, 255);
-   init_x264_param(video->codec);
 
    if (avcodec_open(video->codec, codec) != 0)
-      return -1;
+      return false;
 
    // Allocate a big buffer :p ffmpeg API doesn't seem to give us some clues how big this buffer should be.
-   video->outbuf_size = 1000000;
+   video->outbuf_size = 1 << 23;
    video->outbuf = av_malloc(video->outbuf_size);
 
-   int size = avpicture_get_size(PIX_FMT_YUV420P, param->out_width, param->out_height);
+   // 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);
    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_YUV420P, param->out_width, param->out_height);
+   avpicture_fill((AVPicture*)video->conv_frame, video->conv_frame_buf, PIX_FMT_RGB32, param->fb_width, param->fb_height);
 
-   return 0;
+   return true;
 }
 
-static int init_muxer(ffemu_t *handle)
+static bool init_muxer(ffemu_t *handle)
 {
    AVFormatContext *ctx = avformat_alloc_context();
    av_strlcpy(ctx->filename, handle->params.filename, sizeof(ctx->filename));
    ctx->oformat = av_guess_format(NULL, ctx->filename, NULL);
+#ifdef AVIO_FLAG_WRITE
+   if (avio_open(&ctx->pb, ctx->filename, AVIO_FLAG_WRITE) < 0)
+#else
    if (url_fopen(&ctx->pb, ctx->filename, URL_WRONLY) < 0)
+#endif
    {
       av_free(ctx);
-      return -1;
+      return false;
    }
 
    int stream_cnt = 0;
-   if (handle->video.enabled)
-   {
-      AVStream *stream = av_new_stream(ctx, stream_cnt++);
-      stream->codec = handle->video.codec;
+   AVStream *stream = av_new_stream(ctx, stream_cnt++);
+   stream->codec = handle->video.codec;
 
-      if (ctx->oformat->flags & AVFMT_GLOBALHEADER)
-         handle->video.codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
-      handle->muxer.vstream = stream;
-      handle->muxer.vstream->sample_aspect_ratio = handle->video.codec->sample_aspect_ratio;
-   }
+   if (ctx->oformat->flags & AVFMT_GLOBALHEADER)
+      handle->video.codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
+   handle->muxer.vstream = stream;
+   handle->muxer.vstream->sample_aspect_ratio = handle->video.codec->sample_aspect_ratio;
 
-   if (handle->audio.enabled)
-   {
-      AVStream *stream = av_new_stream(ctx, stream_cnt++);
-      stream->codec = handle->audio.codec;
+   stream = av_new_stream(ctx, stream_cnt++);
+   stream->codec = handle->audio.codec;
 
-      if (ctx->oformat->flags & AVFMT_GLOBALHEADER)
-         handle->audio.codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
-      handle->muxer.astream = stream;
-   }
+   if (ctx->oformat->flags & AVFMT_GLOBALHEADER)
+      handle->audio.codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
+   handle->muxer.astream = stream;
 
    if (av_write_header(ctx) < 0)
-      return -1;
+      return false;
 
    handle->muxer.ctx = ctx;
-   return 0;
+   return true;
+}
+
+#define MAX_FRAMES 64
+
+static int SDLCALL 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->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 *
+            handle->video.pix_size * MAX_FRAMES));
+
+   handle->alive = true;
+   handle->can_sleep = true;
+   assert(handle->thread = SDL_CreateThread(ffemu_thread, handle));
+
+   return true;
+}
+
+static void deinit_thread(ffemu_t *handle)
+{
+   if (handle->thread)
+   {
+      SDL_mutexP(handle->cond_lock);
+      handle->alive = false;
+      handle->can_sleep = false;
+      SDL_mutexV(handle->cond_lock);
+
+      SDL_CondSignal(handle->cond);
+      SDL_WaitThread(handle->thread, NULL);
+
+      SDL_DestroyMutex(handle->lock);
+      SDL_DestroyMutex(handle->cond_lock);
+      SDL_DestroyCond(handle->cond);
+
+      handle->thread = NULL;
+   }
+}
+
+static void deinit_thread_buf(ffemu_t *handle)
+{
+   if (handle->audio_fifo)
+   {
+      fifo_free(handle->audio_fifo);
+      handle->audio_fifo = NULL;
+   }
+   
+   if (handle->attr_fifo)
+   {
+      fifo_free(handle->attr_fifo);
+      handle->attr_fifo = NULL;
+   }
+
+   if (handle->video_fifo)
+   {
+      fifo_free(handle->video_fifo);
+      handle->video_fifo = NULL;
+   }
 }
 
 ffemu_t *ffemu_new(const struct ffemu_params *params)
@@ -219,20 +252,17 @@ ffemu_t *ffemu_new(const struct ffemu_params *params)
       goto error;
 
    handle->params = *params;
-   if (handle->params.vcodec != FFEMU_VIDEO_NONE)
-      handle->video.enabled = true;
-   if (handle->params.acodec != FFEMU_AUDIO_NONE)
-      handle->audio.enabled = true;
 
-   if (handle->video.enabled)
-      if (init_video(&handle->video, &handle->params) < 0)
-         goto error;
+   if (!init_video(&handle->video, &handle->params))
+      goto error;
 
-   if (handle->audio.enabled)
-      if (init_audio(&handle->audio, &handle->params) < 0)
-         goto error;
+   if (!init_audio(&handle->audio, &handle->params))
+      goto error;
 
-   if (init_muxer(handle) < 0)
+   if (!init_muxer(handle))
+      goto error;
+
+   if (!init_thread(handle))
       goto error;
 
    return handle;
@@ -246,6 +276,9 @@ void ffemu_free(ffemu_t *handle)
 {
    if (handle)
    {
+      deinit_thread(handle);
+      deinit_thread_buf(handle);
+
       if (handle->audio.codec)
       {
          avcodec_close(handle->audio.codec);
@@ -267,43 +300,112 @@ void ffemu_free(ffemu_t *handle)
       if (handle->video.conv_frame_buf)
          av_free(handle->video.conv_frame_buf);
 
+      if (handle->video.sws_ctx)
+         sws_freeContext(handle->video.sws_ctx);
+
       free(handle);
    }
 }
 
-// Need to make this thread based, but hey.
 int ffemu_push_video(ffemu_t *handle, const struct ffemu_video_data *data)
 {
-   if (!handle->video.enabled)
-      return -1;
+   for (;;)
+   {
+      SDL_mutexP(handle->lock);
+      unsigned avail = fifo_write_avail(handle->attr_fifo);
+      SDL_mutexV(handle->lock);
 
-   // This is deprecated, can't find a replacement... :(
-   // Hardcode pixel format for now (SNES)
-   struct SwsContext *conv_ctx = sws_getContext(data->width, data->height, PIX_FMT_RGB555LE,
-         handle->params.out_width, handle->params.out_height, PIX_FMT_YUV420P, handle->params.rescaler == FFEMU_RESCALER_LANCZOS ? SWS_LANCZOS : SWS_POINT,
+      if (!handle->alive)
+         return -1;
+
+      if (avail >= sizeof(*data))
+         break;
+
+      SDL_mutexP(handle->cond_lock);
+      if (handle->can_sleep)
+      {
+         handle->can_sleep = false;
+         SDL_CondWait(handle->cond, handle->cond_lock);
+         handle->can_sleep = true;
+      }
+      else
+         SDL_CondSignal(handle->cond);
+
+      SDL_mutexV(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);
+
+   return 0;
+}
+
+int ffemu_push_audio(ffemu_t *handle, const struct ffemu_audio_data *data)
+{
+   for (;;)
+   {
+      SDL_mutexP(handle->lock);
+      unsigned avail = fifo_write_avail(handle->audio_fifo);
+      SDL_mutexV(handle->lock);
+
+      if (!handle->alive)
+         return -1;
+
+      if (avail >= data->frames * handle->params.channels * sizeof(int16_t))
+         break;
+
+      SDL_mutexP(handle->cond_lock);
+      if (handle->can_sleep)
+      {
+         handle->can_sleep = false;
+         SDL_CondWait(handle->cond, handle->cond_lock);
+         handle->can_sleep = true;
+      }
+      else
+         SDL_CondSignal(handle->cond);
+
+      SDL_mutexV(handle->cond_lock);
+   }
+
+   SDL_mutexP(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);
+
+   return 0;
+}
+
+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,
          NULL, NULL, NULL);
 
    int linesize = data->pitch;
 
-   sws_scale(conv_ctx, (const uint8_t* const*)&data->data, &linesize, 0, handle->params.out_width, handle->video.conv_frame->data, handle->video.conv_frame->linesize);
+   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);
 
    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);
+   int outsize = avcodec_encode_video(handle->video.codec, handle->video.outbuf,
+         handle->video.outbuf_size, handle->video.conv_frame);
 
    if (outsize < 0)
       return -1;
 
-   sws_freeContext(conv_ctx);
-
    AVPacket pkt;
    av_init_packet(&pkt);
    pkt.stream_index = handle->muxer.vstream->index;
    pkt.data = handle->video.outbuf;
    pkt.size = outsize;
 
-   pkt.pts = av_rescale_q(handle->video.codec->coded_frame->pts, handle->video.codec->time_base, handle->muxer.vstream->time_base);
+   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;
@@ -319,16 +421,8 @@ int ffemu_push_video(ffemu_t *handle, const struct ffemu_video_data *data)
    return 0;
 }
 
-int ffemu_push_audio(ffemu_t *handle, const struct ffemu_audio_data *data)
+static int ffemu_push_audio_thread(ffemu_t *handle, const struct ffemu_audio_data *data)
 {
-   if (!handle->audio.enabled)
-      return -1;
-
-   AVPacket pkt;
-   av_init_packet(&pkt);
-   pkt.stream_index = handle->muxer.astream->index;
-   pkt.data = handle->audio.outbuf;
-
    size_t written_frames = 0;
    while (written_frames < data->frames)
    {
@@ -344,6 +438,10 @@ int ffemu_push_audio(ffemu_t *handle, const struct ffemu_audio_data *data)
 
       if (handle->audio.frames_in_buffer == (size_t)handle->audio.codec->frame_size)
       {
+         AVPacket pkt;
+         av_init_packet(&pkt);
+         pkt.data = handle->audio.outbuf;
+         pkt.stream_index = handle->muxer.astream->index;
 
          int out_size = avcodec_encode_audio(handle->audio.codec, handle->audio.outbuf, handle->audio.outbuf_size, handle->audio.buffer);
          if (out_size < 0)
@@ -351,13 +449,9 @@ int ffemu_push_audio(ffemu_t *handle, const struct ffemu_audio_data *data)
 
          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.flags |= AV_PKT_FLAG_KEY;
          handle->audio.frames_in_buffer = 0;
@@ -375,38 +469,147 @@ int ffemu_push_audio(ffemu_t *handle, const struct ffemu_audio_data *data)
 
 int ffemu_finalize(ffemu_t *handle)
 {
-   // Push out delayed frames. (MPEG codecs)
-   if (handle->video.enabled)
+   deinit_thread(handle);
+
+   // 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)
    {
-      AVPacket pkt;
-      av_init_packet(&pkt);
-      pkt.stream_index = handle->muxer.vstream->index;
-      pkt.data = handle->video.outbuf;
-
-      int out_size = 0;
-      do
+      struct ffemu_video_data attr_buf;
+      while (fifo_read_avail(handle->attr_fifo) >= sizeof(attr_buf))
       {
-         out_size = avcodec_encode_video(handle->video.codec, handle->video.outbuf, handle->video.outbuf_size, NULL);
-         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);
+         fifo_read(handle->attr_fifo, &attr_buf, sizeof(attr_buf));
+         fifo_read(handle->video_fifo, video_buf, attr_buf.height * attr_buf.pitch);
+         attr_buf.data = video_buf;
+         ffemu_push_video_thread(handle, &attr_buf);
+      }
+      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)
+   AVPacket pkt;
+   av_init_packet(&pkt);
+   pkt.stream_index = handle->muxer.vstream->index;
+   pkt.data = handle->video.outbuf;
+
+   int out_size = 0;
+   do
+   {
+      out_size = avcodec_encode_video(handle->video.codec, handle->video.outbuf, handle->video.outbuf_size, NULL);
+      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);
+
    // Write final data.
    av_write_trailer(handle->muxer.ctx);
 
    return 0;
 }
 
+static int SDLCALL ffemu_thread(void *data)
+{
+   ffemu_t *ff = data;
+
+   // For some reason, FFmpeg has a tendency to crash if we don't overallocate a bit. :s
+   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);
+   int16_t *audio_buf = av_malloc(audio_buf_size);
+   assert(audio_buf);
+
+   struct ffemu_video_data attr_buf;
+
+   while (ff->alive)
+   {
+      bool avail_video = false;
+      bool avail_audio = false;
+
+      SDL_mutexP(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);
+
+      if (!avail_video && !avail_audio)
+      {
+         SDL_mutexP(ff->cond_lock);
+         if (ff->can_sleep)
+         {
+            ff->can_sleep = false;
+            SDL_CondWait(ff->cond, ff->cond_lock);
+            ff->can_sleep = true;
+         }
+         else
+            SDL_CondSignal(ff->cond);
+
+         SDL_mutexV(ff->cond_lock);
+      }
+
+      if (avail_video)
+      {
+         SDL_mutexP(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);
+
+         attr_buf.data = video_buf;
+         ffemu_push_video_thread(ff, &attr_buf);
+      }
+
+      if (avail_audio)
+      {
+         SDL_mutexP(ff->lock);
+         fifo_read(ff->audio_fifo, audio_buf, audio_buf_size);
+         SDL_mutexV(ff->lock);
+         SDL_CondSignal(ff->cond);
+
+         struct ffemu_audio_data aud = {
+            .frames = 128,
+            .data = audio_buf
+         };
+
+         ffemu_push_audio_thread(ff, &aud);
+      }
+   }
+
+   av_free(video_buf);
+   av_free(audio_buf);
+
+   return 0;
+}

record/ffemu.h

@@ -8,36 +8,6 @@
 extern "C" {
 #endif
 
-// Available video codecs
-typedef enum ffemu_video_codec
-{
-   FFEMU_VIDEO_NONE,
-   FFEMU_VIDEO_H264,
-   FFEMU_VIDEO_MPEG4,
-} ffemu_video_codec;
-
-// Available audio codecs
-typedef enum ffemu_audio_codec
-{
-   FFEMU_AUDIO_NONE,
-   FFEMU_AUDIO_VORBIS,
-   FFEMU_AUDIO_MP3,
-   FFEMU_AUDIO_AAC,
-} ffemu_audio_codec;
-
-// Available pixel formats
-typedef enum ffemu_pixel_format
-{
-   FFEMU_FMT_XBGR1555,
-   FFEMU_FMT_RGB888,
-} ffemu_pixel_format;
-
-typedef enum ffemu_rescaler
-{
-   FFEMU_RESCALER_LANCZOS,
-   FFEMU_RESCALER_POINT
-} ffemu_rescaler;
-
 struct ffemu_rational
 {
    unsigned num;
@@ -47,20 +17,15 @@ struct ffemu_rational
 // Parameters passed to ffemu_new()
 struct ffemu_params
 {
-   // Video codec to use. If not recording video, select FFEMU_VIDEO_NONE.
-   ffemu_video_codec vcodec;
-
    // Desired output resolution.
    unsigned out_width;
    unsigned out_height;
+
+   // Total size of framebuffer used in input.
+   unsigned fb_width;
+   unsigned fb_height;
    float aspect_ratio;
 
-   // Rescaler for video.
-   ffemu_rescaler rescaler;
-
-   // Pixel format for video input.
-   ffemu_pixel_format format;
-
    // FPS of video input.
    struct ffemu_rational fps;
 
@@ -71,15 +36,15 @@ struct ffemu_params
    // Define some video codec dependent option. (E.g. h264 profiles)
    uint64_t video_opt;
 
-   // Audio codec. If not recording audio, select FFEMU_AUDIO_NONE.
-   ffemu_audio_codec acodec;
-
    // Audio sample rate.
    unsigned samplerate;
 
    // Audio channels.
    unsigned channels;
 
+   // If input is ARGB or XRGB1555.
+   bool rgb32;
+
    // Audio bits. Sample format is always signed PCM in native byte order.
    //unsigned bits;
 
@@ -119,7 +84,6 @@ int ffemu_push_audio(ffemu_t *handle, const struct ffemu_audio_data *data);
 int ffemu_finalize(ffemu_t *handle);
 
 
-
 #ifdef __cplusplus
 }
 #endif

settings.c

@@ -71,12 +71,18 @@ static void set_defaults(void)
       case AUDIO_ROAR:
          def_audio = "roar";
          break;
+      case AUDIO_COREAUDIO:
+         def_audio = "coreaudio";
+         break;
       case AUDIO_AL:
          def_audio = "openal";
          break;
       case AUDIO_SDL:
          def_audio = "sdl";
          break;
+      case AUDIO_DSOUND:
+         def_audio = "dsound";
+         break;
       case AUDIO_XAUDIO:
          def_audio = "xaudio";
          break;
@@ -111,10 +117,11 @@ static void set_defaults(void)
 
    g_settings.video.xscale = xscale;
    g_settings.video.yscale = yscale;
-   g_settings.video.fullscreen = fullscreen;
+   g_settings.video.fullscreen = g_extern.force_fullscreen ? true : fullscreen;
    g_settings.video.fullscreen_x = fullscreen_x;
    g_settings.video.fullscreen_y = fullscreen_y;
    g_settings.video.force_16bit = force_16bit;
+   g_settings.video.disable_composition = disable_composition;
    g_settings.video.vsync = vsync;
    g_settings.video.smooth = video_smooth;
    g_settings.video.force_aspect = force_aspect;
@@ -135,6 +142,9 @@ static void set_defaults(void)
    g_settings.video.second_pass_smooth = second_pass_smooth;
 #endif
 
+   g_settings.video.hires_record = hires_record;
+   g_settings.video.post_filter_record = post_filter_record;
+
    g_settings.audio.enable = audio_enable;
    g_settings.audio.out_rate = out_rate;
    g_settings.audio.in_rate = in_rate;
@@ -194,8 +204,8 @@ static config_file_t *open_default_config_file(void)
       if (appdata)
       {
          char conf_path[strlen(appdata) + strlen("/ssnes.cfg ")];
-         strcpy(conf_path, appdata);
-         strcat(conf_path, "/ssnes.cfg");
+         strlcpy(conf_path, appdata, sizeof(conf_path));
+         strlcat(conf_path, "/ssnes.cfg", sizeof(conf_path));
          conf = config_file_new(conf_path);
       }
    }
@@ -204,8 +214,8 @@ static config_file_t *open_default_config_file(void)
    if (home)
    {
       char conf_path[strlen(home) + strlen("/.ssnes.cfg ")];
-      strcpy(conf_path, home);
-      strcat(conf_path, "/.ssnes.cfg");
+      strlcpy(conf_path, home, sizeof(conf_path));
+      strlcat(conf_path, "/.ssnes.cfg", sizeof(conf_path));
       conf = config_file_new(conf_path);
    }
    if (!conf)
@@ -219,15 +229,15 @@ static config_file_t *open_default_config_file(void)
    if (xdg)
    {
       char conf_path[strlen(xdg) + strlen("/ssnes/ssnes.cfg ")];
-      strcpy(conf_path, xdg);
-      strcat(conf_path, "/ssnes/ssnes.cfg");
+      strlcpy(conf_path, xdg, sizeof(conf_path));
+      strlcat(conf_path, "/ssnes/ssnes.cfg", sizeof(conf_path));
       conf = config_file_new(conf_path);
    }
    else if (home)
    {
       char conf_path[strlen(home) + strlen("/.ssnes.cfg ")];
-      strcpy(conf_path, home);
-      strcat(conf_path, "/.ssnes.cfg");
+      strlcpy(conf_path, home, sizeof(conf_path));
+      strlcat(conf_path, "/.ssnes.cfg", sizeof(conf_path));
       conf = config_file_new(conf_path);
    }
    // Try this as a last chance...
@@ -289,8 +299,14 @@ static void parse_config_file(void)
    CONFIG_GET_DOUBLE(video.yscale, "video_yscale");
    CONFIG_GET_INT(video.fullscreen_x, "video_fullscreen_x");
    CONFIG_GET_INT(video.fullscreen_y, "video_fullscreen_y");
-   CONFIG_GET_BOOL(video.fullscreen, "video_fullscreen");
+
+   if (!g_extern.force_fullscreen)
+   {
+      CONFIG_GET_BOOL(video.fullscreen, "video_fullscreen");
+   }
+
    CONFIG_GET_BOOL(video.force_16bit, "video_force_16bit");
+   CONFIG_GET_BOOL(video.disable_composition, "video_disable_composition");
    CONFIG_GET_BOOL(video.vsync, "video_vsync");
    CONFIG_GET_BOOL(video.smooth, "video_smooth");
    CONFIG_GET_BOOL(video.force_aspect, "video_force_aspect");
@@ -312,6 +328,9 @@ static void parse_config_file(void)
    CONFIG_GET_DOUBLE(video.msg_pos_y, "video_message_pos_y");
 #endif
 
+   CONFIG_GET_BOOL(video.hires_record, "video_hires_record");
+   CONFIG_GET_BOOL(video.post_filter_record, "video_post_filter_record");
+
 #ifdef HAVE_DYLIB
    CONFIG_GET_STRING(video.filter_path, "video_filter");
    CONFIG_GET_STRING(video.external_driver, "video_external_driver");

ssnes.c

@@ -142,14 +142,16 @@ static void video_frame(const uint16_t *data, unsigned width, unsigned height)
    if (g_extern.do_screenshot)
       take_screenshot(data, width, height);
 
+   // Slightly messy code,
+   // but we really need to do processing before blocking on VSync for best possible scheduling.
 #ifdef HAVE_FFMPEG
-   if (g_extern.recording)
+   if (g_extern.recording && (!g_extern.filter.active || !g_settings.video.post_filter_record))
    {
       struct ffemu_video_data ffemu_data = {
          .data = data,
          .pitch = height == 448 || height == 478 ? 1024 : 2048,
          .width = width,
-         .height = height
+         .height = height,
       };
       ffemu_push_video(g_extern.rec, &ffemu_data);
    }
@@ -165,6 +167,20 @@ static void video_frame(const uint16_t *data, unsigned width, unsigned 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);
+
+#ifdef HAVE_FFMPEG
+      if (g_extern.recording && g_settings.video.post_filter_record)
+      {
+         struct ffemu_video_data ffemu_data = {
+            .data = g_extern.filter.buffer,
+            .pitch = g_extern.filter.pitch,
+            .width = owidth,
+            .height = oheight,
+         };
+         ffemu_push_video(g_extern.rec, &ffemu_data);
+      }
+#endif
+
       if (!driver.video->frame(driver.video_data, g_extern.filter.buffer, owidth, oheight, g_extern.filter.pitch, msg))
          g_extern.video_active = false;
    }
@@ -178,32 +194,35 @@ static void video_frame(const uint16_t *data, unsigned width, unsigned height)
 
 static void audio_sample(uint16_t left, uint16_t right)
 {
-   if ( !g_extern.audio_active )
+   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)
    {
-      static int16_t static_data[2];
-      static_data[0] = left;
-      static_data[1] = right;
       struct ffemu_audio_data ffemu_data = {
-         .data = static_data,
-         .frames = 1
+         .data = g_extern.audio_data.conv_outsamples,
+         .frames = g_extern.audio_data.data_ptr / 2
       };
       ffemu_push_audio(g_extern.rec, &ffemu_data);
    }
 #endif
 
-   const float *output_data = NULL;
-   unsigned output_frames = 0;
-
-   g_extern.audio_data.data[g_extern.audio_data.data_ptr++] = (float)(int16_t)left/0x8000; 
-   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;
-
    ssnes_dsp_input_t dsp_input = {
       .samples = g_extern.audio_data.data,
       .frames = g_extern.audio_data.data_ptr / 2
@@ -329,15 +348,15 @@ static void fill_pathname_noext(char *out_path, const char *in_path, const char
 }
 
 #ifdef _WIN32
-#define SSNES_DEFAULT_CONF_PATH_STR "\n\tDefaults to ssnes.cfg in same directory as ssnes.exe"
+#define SSNES_DEFAULT_CONF_PATH_STR "\n\tDefaults to ssnes.cfg in same directory as ssnes.exe."
 #elif defined(__APPLE__)
-#define SSNES_DEFAULT_CONF_PATH_STR " Defaults to $HOME/.ssnes.cfg"
+#define SSNES_DEFAULT_CONF_PATH_STR " Defaults to $HOME/.ssnes.cfg."
 #else
-#define SSNES_DEFAULT_CONF_PATH_STR " Defaults to $XDG_CONFIG_HOME/ssnes/ssnes.cfg"
+#define SSNES_DEFAULT_CONF_PATH_STR " Defaults to $XDG_CONFIG_HOME/ssnes/ssnes.cfg,\n\t\tor $HOME/.ssnes.cfg, if $XDG_CONFIG_HOME is not defined."
 #endif
 
 #ifdef _WIN32
-#define PACKAGE_VERSION "0.5.2"
+#define PACKAGE_VERSION "0.7"
 #endif
 
 #include "config.features.h"
@@ -348,6 +367,7 @@ static void print_features(void)
    puts("");
    puts("Features:");
    _PSUPP(sdl, "SDL", "SDL drivers");
+   _PSUPP(xvideo, "XVideo", "XVideo output");
    _PSUPP(alsa, "ALSA", "audio driver");
    _PSUPP(oss, "OSS", "audio driver");
    _PSUPP(jack, "Jack", "audio driver");
@@ -377,8 +397,9 @@ static void print_help(void)
    puts("ssnes: Simple Super Nintendo Emulator (libsnes) -- v" PACKAGE_VERSION " --");
    puts("===================================================================");
    puts("Usage: ssnes [rom file] [options...]");
-   puts("\t-h/--help: Show this help message");
-   puts("\t-s/--save: Path for save file (*.srm). Required when rom is input from stdin");
+   puts("\t-h/--help: Show this help message.");
+   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.");
 #ifdef HAVE_CONFIGFILE
    puts("\t-c/--config: Path for config file." SSNES_DEFAULT_CONF_PATH_STR);
@@ -389,6 +410,7 @@ static void print_help(void)
    puts("\t--sufamiA: Path to A slot of Sufami Turbo. Load Sufami base cart as regular rom.");
    puts("\t--sufamiB: Path to B slot of Sufami Turbo.");
    puts("\t-m/--mouse: Connect a virtual mouse into designated port of the SNES (1 or 2)."); 
+   puts("\t-N/--nodevice: Disconnects the controller device connected to the emulated SNES (1 or 2).");
    puts("\t\tThis argument can be specified several times to connect more mice.");
    puts("\t-p/--scope: Connect a virtual SuperScope into port 2 of the SNES.");
    puts("\t-j/--justifier: Connect a virtual Konami Justifier into port 2 of the SNES.");
@@ -403,10 +425,11 @@ static void print_help(void)
 #endif
 
 #ifdef HAVE_FFMPEG
-   puts("\t-r/--record: Path to record video file. Settings for video/audio codecs are found in config file.");
+   puts("\t-r/--record: Path to record video file.\n\t\tSettings for video/audio codecs are found in config file.");
 #endif
-   puts("\t-v/--verbose: Verbose logging");
+   puts("\t-v/--verbose: Verbose logging.");
    puts("\t-U/--ups: Specifies path for UPS 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();
@@ -415,7 +438,7 @@ static void print_help(void)
 static void set_basename(const char *path)
 {
    char tmp[strlen(path) + 1];
-   strcpy(tmp, path);
+   strlcpy(tmp, path, sizeof(tmp));
    char *dst = strrchr(tmp, '.');
    if (dst)
       *dst = '\0';
@@ -435,6 +458,7 @@ static void parse_input(int argc, char *argv[])
    struct option opts[] = {
       { "help", 0, NULL, 'h' },
       { "save", 1, NULL, 's' },
+      { "fullscreen", 0, NULL, 'f' },
 #ifdef HAVE_FFMPEG
       { "record", 1, NULL, 'r' },
 #endif
@@ -444,6 +468,7 @@ static void parse_input(int argc, char *argv[])
       { "config", 0, NULL, 'c' },
 #endif
       { "mouse", 1, NULL, 'm' },
+      { "nodevice", 1, NULL, 'N' },
       { "scope", 0, NULL, 'p' },
       { "savestate", 1, NULL, 'S' },
       { "bsx", 1, NULL, 'b' },
@@ -459,6 +484,7 @@ static void parse_input(int argc, char *argv[])
       { "frames", 1, NULL, 'F' },
       { "port", 1, &val, 'p' },
       { "ups", 1, NULL, 'U' },
+      { "xml", 1, NULL, 'X' },
       { "detach", 0, NULL, 'D' },
       { NULL, 0, NULL, 0 }
    };
@@ -477,7 +503,7 @@ static void parse_input(int argc, char *argv[])
 #define CONFIG_FILE_ARG
 #endif
 
-   char optstring[] = "hs:vS:m:p4jJg:b:B:Y:Z:P:HC:F:U:D" FFMPEG_RECORD_ARG CONFIG_FILE_ARG;
+   char optstring[] = "hs:fvS:m:p4jJg:b:B:Y:Z:P:HC:F:U:DN:X:" FFMPEG_RECORD_ARG CONFIG_FILE_ARG;
    for(;;)
    {
       val = 0;
@@ -510,6 +536,10 @@ static void parse_input(int argc, char *argv[])
             g_extern.has_set_save_path = true;
             break;
 
+         case 'f':
+            g_extern.force_fullscreen = true;
+            break;
+
          case 'g':
             strlcpy(g_extern.gb_rom_path, optarg, sizeof(g_extern.gb_rom_path));
             g_extern.game_type = SSNES_CART_SGB;
@@ -555,6 +585,17 @@ static void parse_input(int argc, char *argv[])
             g_extern.has_mouse[port - 1] = true;
             break;
 
+         case 'N':
+            port = strtol(optarg, NULL, 0);
+            if (port < 1 || port > 2)
+            {
+               SSNES_ERR("Disconnected device from port 1 or 2.\n");
+               print_help();
+               exit(1);
+            }
+            g_extern.disconnect_device[port - 1] = true;
+            break;
+
          case 'p':
             g_extern.has_scope[1] = true;
             break;
@@ -596,6 +637,10 @@ static void parse_input(int argc, char *argv[])
             strlcpy(g_extern.ups_name, optarg, sizeof(g_extern.ups_name));
             break;
 
+         case 'X':
+            strlcpy(g_extern.xml_name, optarg, sizeof(g_extern.xml_name));
+            break;
+
          case 'D':
 #ifdef _WIN32
             FreeConsole();
@@ -669,21 +714,26 @@ static void init_controllers(void)
    }
    else if (g_extern.has_multitap)
    {
-      SSNES_LOG("Connecting multitap to port 2.\n");
+      SSNES_LOG("Connecting Multitap to port 2.\n");
       psnes_set_controller_port_device(SNES_PORT_2, SNES_DEVICE_MULTITAP);
    }
    else
    {
-      for (int i = 0; i < 2; i++)
+      for (unsigned i = 0; i < 2; i++)
       {
-         if (g_extern.has_mouse[i])
+         if (g_extern.disconnect_device[i])
          {
-            SSNES_LOG("Connecting mouse to port %d\n", i + 1);
+            SSNES_LOG("Disconnecting device from port %u.\n", i + 1);
+            psnes_set_controller_port_device(i, SNES_DEVICE_NONE);
+         }
+         else if (g_extern.has_mouse[i])
+         {
+            SSNES_LOG("Connecting mouse to port %u.\n", i + 1);
             psnes_set_controller_port_device(i, SNES_DEVICE_MOUSE);
          }
          else if (g_extern.has_scope[i])
          {
-            SSNES_LOG("Connecting scope to port %d\n", i + 1);
+            SSNES_LOG("Connecting scope to port %u.\n", i + 1);
             psnes_set_controller_port_device(i, SNES_DEVICE_SUPER_SCOPE);
          }
       }
@@ -758,30 +808,53 @@ static inline void save_files(void)
 #ifdef HAVE_FFMPEG
 static void init_recording(void)
 {
-   // Hardcode these options at the moment. Should be specificed in the config file later on.
    if (g_extern.recording)
    {
+      // Not perfectly SNES accurate, but this can be adjusted later during processing
+      // and playback losslessly, and we please the containers more by
+      // using "sane" values.
       struct ffemu_rational ntsc_fps = {60000, 1000};
       struct ffemu_rational pal_fps = {50000, 1000};
       struct ffemu_params params = {
-         .vcodec = FFEMU_VIDEO_H264,
-         .acodec = FFEMU_AUDIO_VORBIS,
-         .rescaler = FFEMU_RESCALER_POINT,
-         .out_width = 512,
-         .out_height = 448,
+         .out_width = 256,
+         .out_height = 224,
+         .fb_width = 1024,
+         .fb_height = 512,
          .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
+         .aspect_ratio = 4.0 / 3,
+         .rgb32 = false,
       };
-      SSNES_LOG("Recording with FFmpeg to %s.\n", g_extern.record_path);
+
+      if (g_settings.video.hires_record)
+      {
+         params.out_width = 512;
+         params.out_height = 448;
+      }
+
+      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;
+         g_extern.filter.psize(&max_width, &max_height);
+         params.fb_width = g_extern.filter.pitch >> 2;
+         params.fb_height = next_pow2(max_height);
+      }
+
+      SSNES_LOG("Recording with FFmpeg to %s @ %ux%u. (FB size: %ux%u 32-bit: %s)\n", g_extern.record_path, params.out_width, params.out_height, params.fb_width, params.fb_height, params.rgb32 ? "yes" : "no");
       g_extern.rec = ffemu_new(&params);
       if (!g_extern.rec)
       {
          SSNES_ERR("Failed to start FFmpeg recording.\n");
          g_extern.recording = false;
       }
+      else
+         g_settings.video.crop_overscan = true;
    }
 }
 
@@ -855,6 +928,7 @@ static void init_movie(void)
       }
 
       msg_queue_push(g_extern.msg_queue, "Starting movie playback!", 2, 180);
+      g_settings.rewind_granularity = 1;
       SSNES_LOG("Starting movie playback!\n");
    }
 }
@@ -875,7 +949,6 @@ static void init_netplay(void)
       struct snes_callbacks cbs = {
          .frame_cb = video_frame,
          .sample_cb = audio_sample,
-         .poll_cb = input_poll,
          .state_cb = input_state
       };
 
@@ -1006,6 +1079,9 @@ static void fill_pathnames(void)
 
    if (!(*g_extern.ups_name) && *g_extern.basename)
       fill_pathname_noext(g_extern.ups_name, g_extern.basename, ".ups", sizeof(g_extern.ups_name));
+
+   if (!(*g_extern.xml_name) && *g_extern.basename)
+      fill_pathname_noext(g_extern.xml_name, g_extern.basename, ".xml", sizeof(g_extern.xml_name));
 }
 
 // Save or load state here.
@@ -1160,8 +1236,7 @@ static void check_rewind(void)
 
          if (g_extern.bsv_movie)
          {
-            for (unsigned i = 0; i < (g_settings.rewind_granularity ? g_settings.rewind_granularity : 1); i++)
-               bsv_movie_frame_rewind(g_extern.bsv_movie);
+            bsv_movie_frame_rewind(g_extern.bsv_movie);
          }
       }
       else
@@ -1195,6 +1270,7 @@ static void check_movie_record(void)
       }
       else
       {
+         g_settings.rewind_granularity = 1;
          char path[512];
          if (g_extern.state_slot > 0)
             snprintf(path, sizeof(path), "%s%d.bsv", g_extern.bsv_movie_path, g_extern.state_slot);
@@ -1477,14 +1553,13 @@ int main(int argc, char *argv[])
 #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);
-   psnes_set_input_poll(g_extern.netplay ? input_poll_net : input_poll);
    psnes_set_input_state(g_extern.netplay ? input_state_net : input_state);
 #else
    psnes_set_video_refresh(video_frame);
    psnes_set_audio_sample(audio_sample);
-   psnes_set_input_poll(input_poll);
    psnes_set_input_state(input_state);
 #endif
+   psnes_set_input_poll(input_poll);
    
    init_controllers();
    
@@ -1498,6 +1573,10 @@ int main(int argc, char *argv[])
    // Main loop
    for(;;)
    {
+      // DSP plugin GUI events.
+      if (g_extern.audio_data.dsp_handle && g_extern.audio_data.dsp_plugin->events)
+         g_extern.audio_data.dsp_plugin->events(g_extern.audio_data.dsp_handle);
+
       // Time to drop?
       if (driver.input->key_pressed(driver.input_data, SSNES_QUIT_KEY) ||
             !driver.video->alive(driver.video_data) || g_extern.bsv_movie_end)

ssnes.cfg

@@ -25,6 +25,9 @@
 # Force 16-bit colors. Apparently some video cards in use today have troubles with 32-bit ...
 # video_force_16bit = false
 
+# Forcibly disable composition. Only works in Windows Vista/7 for now.
+# video_disable_composition = false
+
 # Video vsync.
 # video_vsync = true
 
@@ -290,3 +293,9 @@
 
 # Directory to dump screenshots to.
 # screenshot_directory =
+
+# Records video assuming video is hi-res.
+# video_hires_record = false
+
+# Records video after CPU video filter.
+# video_post_filter_record = false