(Android) use libretro.org for overlay manual, not github repo

If "neon" appears in name, and NEON isn't supported,
that libretro core will not be used.

.gitignore

@@ -1,3 +1,31 @@
 *.o
-ssnes
+*.bmpobj
+*.binobj
+*.so
+*.dll
+*.a
+*.elf
+*.dol
+*.map
+config.log
+/retroarch
+/retroarch.*
 /config.h
+/config.mk
+/tools/retroarch-joyconfig
+/tools/retroarch-joyconfig.*
+*.ncb
+*.sdf
+*.opensdf
+*.suo
+Debug
+Release
+ipch
+*.user
+/wii/app_booter/app_booter.bin
+*.zip
+RetroArch-w32/
+RetroArch-w64/
+android/native/obj/
+android/phoenix/bin/
+android/phoenix/gen/

AUTHORS

@@ -1,5 +1,46 @@
 Hans-Kristian Arntzen - <[email protected]>
    - Main code, maintainer
+   - Initial Gamecube/Wii libogc port
 
 Devin J. Pohly - <[email protected]>
    - Joypad axis support
+
+Chris Moeller - <[email protected]> 
+   - CoreAudio audio driver
+
+Daniel De Matteis - <[email protected]>
+   - PlayStation 3 port
+   - XBox 360 XDK port
+   - Libxenon port
+   - XBox 1 port
+   - Android port
+   - OpenSL ES audio driver
+   - Gamecube/Wii libogc port
+
+Meancoot - <TBA>
+   - Phoenix Java frontend
+   - Android port patches
+
+David Reichelt - <[email protected]>
+   - XBox 1 port
+
+tukuyomi - <[email protected]>
+   - Cleanups in quickbuild
+
+Michael Lelli - <[email protected]>
+   - Gamecube/Wii libogc port
+   - Raspberry Pi video driver
+   - Linux Raw keyboard input driver
+   - Android port patches
+
+Darren Alton -
+   - OpenPandora port
+
+Fabian Knopf -
+   - WGL multi-monitor support
+
+Gražvydas Ignotas -
+   - ARM Linux patches
+
+Saggi Mizrahi - 
+   - RetroLaunch utility

CONTRIBUTING.md

@@ -0,0 +1,58 @@
+# Contributing to RetroArch
+
+If you are a developer and want to contribute to the development of RetroArch, please read this.
+If you have found a bug and want to submit a minor patch or a bug report, please read this as well.
+
+# Submitting a bug report
+When submitting a bug report, make sure that the bug is local to RetroArch.
+A bug in a libretro core or something deemed to be external is likely to be closed very fast.
+If you still suspect a bug in RetroArch, make sure to test with several cores to make sure.
+
+If you have troubles building RetroArch on Linux/BSD/OSX, make sure to paste shell output of ./configure,
+as well as config.log and shell output of make. If building on Windows, just paste shell output of make.
+
+If the issue occurs during runtime, make sure to paste RetroArch's verbose log.
+If using Phoenix frontend, you can find log in (File -> Show Log) after running.
+In console, make sure to run with verbose (-v) flag.
+
+# Pull Requests
+Outside contributions are generally only accepted in the form of a pull request. The process is very simple.
+Fork RetroArch, make your changes, and issue a pull request on GitHub. This can all be done within the browser.
+The changes are reviewed, and might be merged in. If the pull request isn't acceptable at the time,
+note that it's possible to continue pushing up commits to your branch.
+
+If you want to develop a larger feature,
+we'd like to discuss this first (ideally on IRC) so that you don't risk developing something
+that won't be merged. A pull request with a proof-of-concept is fine, but please indicate so.
+
+## libretro API
+If you wish to add functionality to libretro's API, it can take some time to merge in, because changes
+to libretro API will affect other projects as well, and we highly value API/ABI stability.
+Features will only be added when deemed *necessary* for a concrete libretro core to function properly.
+Features will not be added on basis of hypothetical libretro implementations.
+
+# Coding style
+Having a consistent code style throughout the code base is highly valued.
+Please look through the code to get a feel for the coding style.
+A pull request may be asked to fix the coding style before submission.
+In other cases, a pull request may be followed up with a "style nit commit".
+
+## Non-obvious things:
+  - Code should be both ISO C99 and ISO C++ compatible. This dual requirement is for XBox360 and MSVC in general. Think of it as a C++ compatible subset of C99.
+  - Warnings are not allowed (-Wall). Make sure your code is warning-free. Note that warning sensitivity differs a bit across compiler versions.
+  - Using deprecated APIs is discouraged.
+
+# Copyright Headers and AUTHORS
+If you have contributed to a part of a source file (a chunk of code that's written by you),
+you should add yourself to the copyright header in that file.
+If you have contributed significantly
+(a feature, a contribution you can "name", e.g. "Added audio driver foo"), you should add yourself to AUTHORS file.
+We'd like your full name and email, and which features you have been part of.
+
+# IRC
+Active development happens on IRC. (#retroarch @ irc.freenode.org)
+We value discussing things in "real-time".
+
+# Commit Access
+Contributors who show a track record of making good pull requests over time will eventually get commit access to the repo.
+This typically happens when the "overhead" of looking through pull requests over time becomes a burden.

Makefile

@@ -1,96 +1,336 @@
 include config.mk
 
-TARGET = ssnes tools/ssnes-joyconfig
+TARGET = retroarch tools/retroarch-joyconfig tools/retrolaunch/retrolaunch
+
+OBJ = retroarch.o \
+		file.o \
+		file_path.o \
+		hash.o \
+		driver.o \
+		settings.o \
+		dynamic.o \
+		message.o \
+		rewind.o \
+		gfx/gfx_common.o \
+		input/input_common.o \
+		input/overlay.o \
+		patch.o \
+		fifo_buffer.o \
+		compat/compat.o \
+		cheats.o \
+		conf/config_file.o \
+		screenshot.o \
+		gfx/scaler/scaler.o \
+		gfx/scaler/pixconv.o \
+		gfx/scaler/scaler_int.o \
+		gfx/scaler/filter.o \
+		gfx/image.o \
+		gfx/fonts/fonts.o \
+		gfx/fonts/bitmapfont.o \
+		performance.o
+
+JOYCONFIG_OBJ = tools/retroarch-joyconfig.o \
+	conf/config_file.o \
+	file_path.o \
+	compat/compat.o \
+	input/input_common.o
+
+RETROLAUNCH_OBJ = tools/retrolaunch/main.o \
+	tools/retrolaunch/sha1.o \
+	tools/retrolaunch/parser.o \
+	tools/retrolaunch/cd_detect.o \
+	tools/retrolaunch/rl_fnmatch.o \
+	file_path.o \
+	compat/compat.o \
+	conf/config_file.o \
+	settings.o
 
-OBJ = ssnes.o file.o driver.o settings.o dynamic.o message.o
-JOYCONFIG_OBJ = tools/ssnes-joyconfig.o conf/config_file.o
 HEADERS = $(wildcard */*.h) $(wildcard *.h)
 
-LIBS =
-DEFINES = -DHAVE_CONFIG_H
-
-ifeq ($(HAVE_SRC), 1)
-   LIBS += $(SRC_LIBS)
-   DEFINES += $(SRC_CFLAGS)
+ifeq ($(findstring Haiku,$(OS)),)
+	LIBS = -lm
 endif
 
-ifeq ($(HAVE_CONFIGFILE), 1)
-   OBJ += conf/config_file.o
+DEFINES = -DHAVE_CONFIG_H -DHAVE_SCREENSHOTS
+
+ifeq ($(REENTRANT_TEST), 1)
+   DEFINES += -Dmain=retroarch_main
+   OBJ += console/test.o
+endif
+
+ifneq ($(findstring Darwin,$(OS)),)
+   OSX := 1
+   LIBS += -framework AppKit
+else
+   OSX := 0
+endif
+
+ifneq ($(findstring BSD,$(OS)),)
+   BSD_LOCAL_INC = -I/usr/local/include
+endif
+
+ifneq ($(findstring Linux,$(OS)),)
+   LIBS += -lrt
+   OBJ += input/linuxraw_input.o input/linuxraw_joypad.o
+   JOYCONFIG_OBJ += input/linuxraw_joypad.o
+endif
+
+OBJ += autosave.o thread.o
+
+ifeq ($(HAVE_THREADS), 1)
+   ifeq ($(findstring Haiku,$(OS)),)
+      LIBS += -lpthread
+   endif
+endif
+
+ifeq ($(HAVE_BSV_MOVIE), 1)
+   OBJ += movie.o
+endif
+
+ifeq ($(HAVE_NETPLAY), 1)
+   OBJ += netplay.o
+endif
+
+ifeq ($(HAVE_COMMAND), 1)
+   OBJ += command.o
 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_ALSA), 1)
-   OBJ += audio/alsa.o
-   LIBS += -lasound
+
+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 audio/alsathread.o
+   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
-   LIBS += -lopenal
+   ifeq ($(OSX),1)
+      LIBS += -framework OpenAL
+   else
+      LIBS += -lopenal
+   endif
 endif
+
 ifeq ($(HAVE_JACK),1)
    OBJ += audio/jack.o
-   LIBS += -ljack
+   LIBS += $(JACK_LIBS)
+   DEFINES += $(JACK_CFLAGS)
+endif
+
+ifeq ($(HAVE_PULSE), 1)
+   OBJ += audio/pulse.o
+   LIBS += $(PULSE_LIBS)
+   DEFINES += $(PULSE_CFLAGS)
+endif
+
+ifeq ($(HAVE_COREAUDIO), 1)
+   OBJ += audio/coreaudio.o
+   LIBS += -framework CoreServices -framework CoreAudio -framework AudioUnit
+endif
+
+ifeq ($(SCALER_NO_SIMD), 1)
+   DEFINES += -DSCALER_NO_SIMD
+endif
+
+ifeq ($(PERF_TEST), 1)
+   DEFINES += -DPERF_TEST
 endif
 
 ifeq ($(HAVE_SDL), 1)
-   OBJ += gfx/gl.o input/sdl.o audio/sdl.o audio/buffer.o
-   LIBS += $(SDL_LIBS) -lGL
-   DEFINES += $(SDL_CFLAGS)
+   OBJ += gfx/sdl_gfx.o input/sdl_input.o input/sdl_joypad.o audio/sdl_audio.o
+   JOYCONFIG_OBJ += input/sdl_joypad.o
+   DEFINES += $(SDL_CFLAGS) $(BSD_LOCAL_INC)
+   LIBS += $(SDL_LIBS)
+
+   ifeq ($(HAVE_OPENGL), 1)
+      OBJ += gfx/context/sdl_ctx.o
+   endif
+endif
+
+ifeq ($(HAVE_OPENGL), 1)
+   OBJ += gfx/gl.o \
+			 gfx/gfx_context.o \
+			 gfx/fonts/gl_font.o \
+			 gfx/fonts/gl_raster_font.o \
+			 gfx/math/matrix.o \
+			 gfx/state_tracker.o
+
+   ifeq ($(HAVE_KMS), 1)
+      OBJ += gfx/context/drm_egl_ctx.o
+      DEFINES += $(GBM_CFLAGS) $(DRM_CFLAGS) $(EGL_CFLAGS)
+      LIBS += $(GBM_LIBS) $(DRM_LIBS) $(EGL_LIBS)
+   endif
+
+   ifeq ($(HAVE_VIDEOCORE), 1)
+      OBJ += gfx/context/vc_egl_ctx.o
+		# videocore's libs set later
+   endif
+
+   ifeq ($(HAVE_X11), 1)
+      ifeq ($(HAVE_GLES), 0)
+         OBJ += gfx/context/glx_ctx.o
+      endif
+      ifeq ($(HAVE_EGL), 1)
+         OBJ += gfx/context/xegl_ctx.o
+         DEFINES += $(EGL_CFLAGS)
+         LIBS += $(EGL_LIBS)
+      endif
+   endif
+	
+   ifeq ($(HAVE_GLES), 1)
+      LIBS += -lGLESv2
+      DEFINES += -DHAVE_OPENGLES -DHAVE_OPENGLES2
+   else
+      ifeq ($(OSX), 1)
+         LIBS += -framework OpenGL
+      else
+         LIBS += -lGL
+      endif
+   endif
+
+   OBJ += gfx/shader_glsl.o 
+   DEFINES += -DHAVE_GLSL -DHAVE_OVERLAY
+endif
+
+ifeq ($(HAVE_VG), 1)
+   OBJ += gfx/vg.o gfx/math/matrix_3x3.o
+   DEFINES += $(VG_CFLAGS)
+   LIBS += $(VG_LIBS)
+endif
+
+ifeq ($(HAVE_VIDEOCORE), 1)
+   LIBS += -lbcm_host -lvcos -lvchiq_arm
+endif
+
+ifeq ($(HAVE_XVIDEO), 1)
+   OBJ += gfx/xvideo.o
+   LIBS += $(XVIDEO_LIBS) 
+   DEFINES += $(XVIDEO_CFLAGS)
+endif
+
+ifeq ($(HAVE_X11), 1)
+   OBJ += input/x11_input.o gfx/context/x11_common.o
+   LIBS += $(X11_LIBS) $(XEXT_LIBS) $(XF86VM_LIBS) $(XINERAMA_LIBS)
+   DEFINES += $(X11_CFLAGS) $(XEXT_CFLAGS) $(XF86VM_CFLAGS) $(XINERAMA_CFLAGS)
 endif
 
 ifeq ($(HAVE_CG), 1)
    OBJ += gfx/shader_cg.o
-   LIBS += -lCg -lCgGL
+   ifeq ($(OSX), 1)
+      LIBS += -framework Cg
+   else
+      LIBS += -lCg -lCgGL
+   endif
 endif
 
-ifeq ($(HAVE_XML), 1)
-   OBJ += gfx/shader_glsl.o
-   LIBS += $(XML_LIBS)
-   DEFINES += $(XML_CFLAGS)
+ifeq ($(HAVE_LIBXML2), 1)
+   LIBS += $(LIBXML2_LIBS)
+   DEFINES += $(LIBXML2_CFLAGS)
+else
+   OBJ += compat/rxml/rxml.o
 endif
 
-ifeq ($(HAVE_FILTER), 1)
-   OBJ += hqflt/hq.o
-   OBJ += hqflt/grayscale.o
-   OBJ += hqflt/bleed.o
-   OBJ += hqflt/ntsc.o
-   OBJ += hqflt/snes_ntsc/snes_ntsc.o
+ifeq ($(HAVE_DYLIB), 1)
+   LIBS += $(DYLIB_LIB)
 endif
 
 ifeq ($(HAVE_FREETYPE), 1)
-   OBJ += gfx/fonts.o
+   OBJ += gfx/fonts/freetype.o
    LIBS += $(FREETYPE_LIBS)
    DEFINES += $(FREETYPE_CFLAGS)
 endif
 
+ifeq ($(HAVE_SDL_IMAGE), 1)
+   LIBS += $(SDL_IMAGE_LIBS)
+   DEFINES += $(SDL_IMAGE_CFLAGS)
+endif
+
+ifeq ($(HAVE_ZLIB), 1)
+   OBJ += gfx/rpng/rpng.o file_extract.o
+   LIBS += $(ZLIB_LIBS)
+   DEFINES += $(ZLIB_CFLAGS) -DHAVE_ZLIB_DEFLATE
+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)
+   LIBS += $(libretro)
+endif
+
+ifeq ($(HAVE_PYTHON), 1)
+   DEFINES += $(PYTHON_CFLAGS) -Wno-unused-parameter
+   LIBS += $(PYTHON_LIBS)
+   OBJ += gfx/py_state/py_state.o
+endif
+
+ifeq ($(HAVE_SINC), 1)
+   OBJ += audio/sinc.o
+
+   ifeq ($(HAVE_NEON),1)
+      OBJ += audio/sinc_neon.o
+   endif
+else
+   OBJ += audio/hermite.o
+endif
+OBJ += audio/utils.o
+ifeq ($(HAVE_NEON),1)
+   OBJ += audio/utils_neon.o
 endif
 
 ifneq ($(V),1)
    Q := @
 endif
 
-CFLAGS = -Wall -O3 -g -std=gnu99 -I.
+OPTIMIZE_FLAG = -O3
+ifeq ($(DEBUG), 1)
+   OPTIMIZE_FLAG = -O0
+endif
+
+CFLAGS += -Wall $(OPTIMIZE_FLAG) $(INCLUDE_DIRS) -g -I.
+ifeq ($(CXX_BUILD), 1)
+   LD = $(CXX)
+   CFLAGS += -std=c++0x -xc++ -D__STDC_CONSTANT_MACROS
+else
+   LD = $(CC)
+   ifneq ($(findstring icc,$(CC)),)
+      CFLAGS += -std=c99 -D_GNU_SOURCE
+   else
+      CFLAGS += -std=gnu99
+   endif
+endif
+
+ifeq ($(NOUNUSED), yes)
+   CFLAGS += -Wno-unused-result
+endif
 
 all: $(TARGET) config.mk
 
@@ -98,41 +338,69 @@ config.mk: configure qb/*
 	@echo "config.mk is outdated or non-existing. Run ./configure again."
 	@exit 1
 
-ssnes: $(OBJ)
-	$(Q)$(CXX) -o $@ $(OBJ) $(LIBS) $(LDFLAGS)
+retroarch: $(OBJ)
 	@$(if $(Q), $(shell echo echo LD $@),)
+	$(Q)$(LD) -o $@ $(OBJ) $(LIBS) $(LDFLAGS) $(LIBRARY_DIRS)
 
-tools/ssnes-joyconfig: $(JOYCONFIG_OBJ)
-	$(Q)$(CC) -o $@ $(JOYCONFIG_OBJ) $(SDL_LIBS) $(LDFLAGS)
+tools/retroarch-joyconfig: $(JOYCONFIG_OBJ)
 	@$(if $(Q), $(shell echo echo LD $@),)
+ifeq ($(CXX_BUILD), 1)
+	$(Q)$(CXX) -o $@ $(JOYCONFIG_OBJ) $(SDL_LIBS) $(LDFLAGS) $(LIBRARY_DIRS)
+else
+	$(Q)$(CC) -o $@ $(JOYCONFIG_OBJ) $(SDL_LIBS) $(LDFLAGS) $(LIBRARY_DIRS)
+endif
+
+tools/retrolaunch/retrolaunch: $(RETROLAUNCH_OBJ)
+	@$(if $(Q), $(shell echo echo LD $@),)
+	$(Q)$(LD) -o $@ $(RETROLAUNCH_OBJ) $(LIBS) $(LDFLAGS) $(LIBRARY_DIRS)
 
 %.o: %.c config.h config.mk $(HEADERS)
-	$(Q)$(CC) $(CFLAGS) $(DEFINES) -c -o $@ $<
 	@$(if $(Q), $(shell echo echo CC $<),)
+	$(Q)$(CC) $(CFLAGS) $(DEFINES) -c -o $@ $<
+
+%.o: %.S config.h config.mk $(HEADERS)
+	@$(if $(Q), $(shell echo echo AS $<),)
+	$(Q)$(CC) $(CFLAGS) $(ASFLAGS) $(DEFINES) -c -o $@ $<
 
 install: $(TARGET)
-	mkdir -p $(DESTDIR)$(PREFIX)/bin
-	mkdir -p $(DESTDIR)/etc
-	mkdir -p $(DESTDIR)$(PREFIX)/share/man/man1
+	mkdir -p $(DESTDIR)$(PREFIX)/bin 2>/dev/null || /bin/true
+	mkdir -p $(DESTDIR)/etc 2>/dev/null || /bin/true
+	mkdir -p $(DESTDIR)$(PREFIX)/share/man/man1 2>/dev/null || /bin/true
+	mkdir -p $(DESTDIR)$(PREFIX)/share/icons 2>/dev/null || /bin/true
 	install -m755 $(TARGET) $(DESTDIR)$(PREFIX)/bin 
-	install -m644 ssnes.cfg $(DESTDIR)/etc/ssnes.cfg
-	install -m644 docs/{ssnes,ssnes-joyconfig}.1 $(DESTDIR)$(PREFIX)/share/man/man1
+	install -m644 retroarch.cfg $(DESTDIR)/etc/retroarch.cfg
+	install -m644 docs/retroarch.1 $(DESTDIR)$(MAN_DIR)
+	install -m644 docs/retroarch-joyconfig.1 $(DESTDIR)$(MAN_DIR)
+	install -m755 retroarch-zip $(DESTDIR)$(PREFIX)/bin
+	install -m644 media/retroarch.png $(DESTDIR)$(PREFIX)/share/icons
 
 uninstall:
-	rm -f $(DESTDIR)$(PREFIX)/bin/{ssnes,ssnes-joyconfig}
-	rm -f $(DESTDIR)/etc/ssnes.cfg
-	rm -f $(DESTDIR)$(PREFIX)/share/man/man1/{ssnes,ssnes-joyconfig}.1
+	rm -f $(DESTDIR)$(PREFIX)/bin/retroarch
+	rm -f $(DESTDIR)$(PREFIX)/bin/retroarch-joyconfig
+	rm -f $(DESTDIR)$(PREFIX)/bin/retrolaunch
+	rm -f $(DESTDIR)$(PREFIX)/bin/retroarch-zip
+	rm -f $(DESTDIR)/etc/retroarch.cfg
+	rm -f $(DESTDIR)$(PREFIX)/share/man/man1/retroarch.1
+	rm -f $(DESTDIR)$(PREFIX)/share/man/man1/retroarch-joyconfig.1
+	rm -f $(DESTDIR)$(PREFIX)/share/icons/retroarch.png
 
 clean:
 	rm -f *.o 
 	rm -f audio/*.o
 	rm -f conf/*.o
 	rm -f gfx/*.o
+	rm -f gfx/rpng/*.o
+	rm -f gfx/fonts/*.o
+	rm -f gfx/math/*.o
+	rm -f gfx/context/*.o
+	rm -f gfx/py_state/*.o
+	rm -f gfx/scaler/*.o
+	rm -f compat/*.o
+	rm -f compat/rxml/*.o
 	rm -f record/*.o
-	rm -f hqflt/*.o
-	rm -f hqflt/snes_ntsc/*.o
 	rm -f input/*.o
 	rm -f tools/*.o
+	rm -f tools/retrolaunch/*.o
 	rm -f $(TARGET)
 
 .PHONY: all install uninstall clean

Makefile.ngc

@@ -0,0 +1,93 @@
+###
+##
+# Makefile for RetroArch GameCube.
+##
+
+DEBUG			= 0
+HAVE_LOGGER		= 1
+HAVE_FILE_LOGGER	= 0
+PERF_TEST		= 0
+
+PC_DEVELOPMENT_IP_ADDRESS	= "192.168.1.7"
+PC_DEVELOPMENT_UDP_PORT		= 3490
+
+# system platform
+system_platform = unix
+ifeq ($(shell uname -a),)
+EXE_EXT = .exe
+   system_platform = win
+else ifneq ($(findstring Darwin,$(shell uname -a)),)
+   system_platform = osx
+else ifneq ($(findstring MINGW,$(shell uname -a)),)
+   system_platform = win
+endif
+
+CC = $(DEVKITPPC)/bin/powerpc-eabi-gcc$(EXE_EXT)
+CXX = $(DEVKITPPC)/bin/powerpc-eabi-g++$(EXE_EXT)
+LD = $(DEVKITPPC)/bin/powerpc-eabi-ld$(EXE_EXT)
+ELF2DOL = $(DEVKITPPC)/bin/elf2dol$(EXE_EXT)
+
+DOL_TARGET := retroarch_ngc.dol
+ELF_TARGET := retroarch_ngc.elf
+
+INCLUDE := -I. -I$(DEVKITPRO)/libogc/include
+LIBDIRS := -L$(DEVKITPRO)/libogc/lib/cube -L.
+
+MACHDEP := -DGEKKO -DHW_DOL -mogc -mcpu=750 -meabi -mhard-float
+CFLAGS += -Wall -std=gnu99 $(MACHDEP) $(INCLUDE)
+LDFLAGS := $(MACHDEP) -Wl,-Map,$(notdir $(ELF_TARGET)).map -T gx/ld/ogc.ld
+LIBS := -lfat -lretro_ngc -logc
+
+OBJ = console/griffin/griffin.o
+
+ifeq ($(PERF_TEST), 1)
+   CFLAGS += -DPERF_TEST
+endif
+
+ifeq ($(HAVE_LOGGER), 1)
+CFLAGS		+= -DHAVE_LOGGER
+CFLAGS          += -DPC_DEVELOPMENT_IP_ADDRESS=\"$(PC_DEVELOPMENT_IP_ADDRESS)\" -DPC_DEVELOPMENT_UDP_PORT=$(PC_DEVELOPMENT_UDP_PORT)
+CFLAGS          += -Iconsole/logger
+LIBS += -lbba
+endif
+
+ifeq ($(HAVE_FILE_LOGGER), 1)
+CFLAGS		+= -DHAVE_FILE_LOGGER
+CFLAGS          += -Iconsole/logger
+endif
+
+CFLAGS += -std=gnu99 -DHAVE_DEFAULT_RETROPAD_INPUT -DHAVE_RMENU -DHAVE_RGUI -DHAVE_THREAD -DRARCH_CONSOLE -DHAVE_LIBRETRO_MANAGEMENT -DHAVE_RARCH_EXEC -DGEKKO -DHAVE_ZLIB -DWANT_RZLIB -DHAVE_RARCH_MAIN_WRAP -DHAVE_GRIFFIN=1 -DHAVE_SCREENSHOTS -DPACKAGE_VERSION=\"0.9.8\" -Dmain=rarch_main -Wno-char-subscripts 
+
+ifeq ($(DEBUG), 1)
+   CFLAGS += -O0 -g
+else
+   CFLAGS += -O3
+endif
+
+all: $(DOL_TARGET)
+
+%.dol: %.elf
+	$(ELF2DOL) $< $@
+
+$(ELF_TARGET): $(OBJ)
+	$(CXX) -o $@ $(LDFLAGS) $(LIBDIRS) $(OBJ) $(LIBS)
+
+%.o: %.c
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+%.binobj: %.bin
+	$(LD) -r -b binary -o $@ $<
+
+%.bmpobj: %.bmp
+	$(LD) -r -b binary -o $@ $<
+
+pkg: all
+	cp -r $(DOL_TARGET) ngc/pkg/CORE.dol
+
+clean:
+	rm -f $(DOL_TARGET)
+	rm -f $(ELF_TARGET)
+	rm -f $(OBJ)
+
+.PHONY: clean
+

Makefile.ngc.salamander

@@ -0,0 +1,83 @@
+
+##
+# Makefile for RetroArch GameCube.
+##
+
+DEBUG			= 0
+HAVE_LOGGER		= 0
+HAVE_FILE_LOGGER	= 0
+
+# system platform
+system_platform = unix
+ifeq ($(shell uname -a),)
+EXE_EXT = .exe
+   system_platform = win
+else ifneq ($(findstring Darwin,$(shell uname -a)),)
+   system_platform = osx
+else ifneq ($(findstring MINGW,$(shell uname -a)),)
+   system_platform = win
+endif
+
+PC_DEVELOPMENT_IP_ADDRESS	= "192.168.1.7"
+PC_DEVELOPMENT_UDP_PORT		= 3490
+
+CC = $(DEVKITPPC)/bin/powerpc-eabi-gcc$(EXE_EXT)
+CXX = $(DEVKITPPC)/bin/powerpc-eabi-g++$(EXE_EXT)
+LD = $(DEVKITPPC)/bin/powerpc-eabi-ld$(EXE_EXT)
+ELF2DOL = $(DEVKITPPC)/bin/elf2dol$(EXE_EXT)
+
+DOL_TARGET := retroarch-salamander_ngc.dol
+ELF_TARGET := retroarch-salamander_ngc.elf
+
+INCLUDE := -I. -I$(DEVKITPRO)/libogc/include
+LIBDIRS := -L$(DEVKITPRO)/libogc/lib/cube -L.
+
+MACHDEP := -DGEKKO -DHW_DOL -mogc -mcpu=750 -meabi -mhard-float
+CFLAGS += -Wall -std=gnu99 $(MACHDEP) $(INCLUDE)
+LDFLAGS := $(MACHDEP) -Wl,-Map,$(notdir $(ELF_TARGET)).map
+LIBS := -lfat -logc
+
+OBJ = frontend/frontend_console.o file_path.o compat/compat.o conf/config_file.o ngc/ssaram.o ngc/sidestep.o
+
+ifeq ($(HAVE_LOGGER), 1)
+CFLAGS		+= -DHAVE_LOGGER
+CFLAGS          += -DPC_DEVELOPMENT_IP_ADDRESS=\"$(PC_DEVELOPMENT_IP_ADDRESS)\" -DPC_DEVELOPMENT_UDP_PORT=$(PC_DEVELOPMENT_UDP_PORT)
+CFLAGS          += -Iconsole/logger
+OBJ             += console/logger/logger.o
+LIBS += -lbba
+endif
+
+ifeq ($(HAVE_FILE_LOGGER), 1)
+CFLAGS		+= -DHAVE_FILE_LOGGER
+CFLAGS          += -Iconsole/logger
+endif
+
+CFLAGS += -std=gnu99 -DHAVE_DEFAULT_RETROPAD_INPUT -DIS_SALAMANDER -DRARCH_CONSOLE -DHAVE_RARCH_EXEC -DGEKKO -DPACKAGE_VERSION=\"0.9.8\" -Wno-char-subscripts 
+
+ifeq ($(DEBUG), 1)
+   CFLAGS += -O0 -g
+else
+   CFLAGS += -O3
+endif
+
+all: $(DOL_TARGET)
+
+%.dol: %.elf
+	$(ELF2DOL) $< $@
+
+$(ELF_TARGET): $(OBJ)
+	$(CXX) -o $@ $(LDFLAGS) $(LIBDIRS) $(OBJ) $(LIBS)
+
+%.o: %.c
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+pkg: all
+	cp -r $(DOL_TARGET) ngc/pkg/boot.dol
+
+clean:
+	rm -f $(DOL_TARGET)
+	rm -f $(ELF_TARGET)
+	rm -f $(OBJ)
+
+.PHONY: clean
+

Makefile.pandora

@@ -0,0 +1,54 @@
+# Before using this Makefile, be sure to do:
+# $ source /usr/local/angstrom/arm/environment-setup
+# $ setprj retroarch
+
+PNDDIR=./pandora
+BINDIR=$(PNDDIR)/bin
+
+all: $(BINDIR)/retroarch
+	mkdir -p $(PNDDIR)/lib
+	@echo "Put libretro-*.so files in $(PNDDIR)/lib/ before making pnd!"
+
+pnd: retroarch.pnd
+
+install: all $(BINDIR)/retroarch-joyconfig $(BINDIR)/retroarch-zip $(PNDDIR)/readme.html
+
+retroarch:
+	./configure --prefix=$PND_BASEDIR/$PRJ --disable-ffmpeg --disable-cg --disable-python --disable-libpng --disable-pulse --disable-jack --enable-gles --enable-xml
+	make -f Makefile
+
+$(BINDIR)/retroarch: retroarch
+	mkdir -p $(BINDIR)
+	cp retroarch $(BINDIR)/retroarch
+
+$(BINDIR)/retroarch-joyconfig: tools/retroarch-joyconfig
+	mkdir -p $(BINDIR)
+	cp tools/retroarch-joyconfig $(BINDIR)/retroarch-joyconfig
+
+$(BINDIR)/retroarch-zip: retroarch-zip
+	mkdir -p $(BINDIR)
+	cp retroarch-zip $(BINDIR)/retroarch-zip
+
+$(PNDDIR)/readme.html: README.md
+	markdown README.md > $(PNDDIR)/readme.html
+
+retroarch.pnd: install
+	pnd_make -c -p retroarch.pnd -d $(PNDDIR)/ -x $(PNDDIR)/PXML.xml -i $(PNDDIR)/icon.png
+
+clean:
+	rm -f *.o 
+	rm -f audio/*.o
+	rm -f conf/*.o
+	rm -f gfx/*.o
+	rm -f gfx/fonts/*.o
+	rm -f gfx/context/*.o
+	rm -f gfx/py_state/*.o
+	rm -f compat/*.o
+	rm -f record/*.o
+	rm -f input/*.o
+	rm -f tools/*.o
+	rm -f $(BINDIR)/retroarch
+	rm -f $(BINDIR)/retroarch-joyconfig
+	rm -f $(PNDDIR)/readme.html
+	rm -f retroarch
+

Makefile.ps3

@@ -0,0 +1,191 @@
+RARCH_VERSION		= "0.9.8"
+
+#which compiler to build  with - GCC or SNC
+#set to GCC for debug builds for use with debugger
+CELL_BUILD_TOOLS	= SNC
+CELL_GPU_TYPE	   	= RSX
+CELL_PSGL_VERSION	= ultra-opt
+
+RMENU_IMG_DIR  := media/rmenu
+
+# options
+DOWNLOAD_SHADERS	= 1
+STRIPPING_ENABLE	= 0
+DEBUG			      = 0
+HAVE_RGL		      = 1
+HAVE_LOGGER		   = 0
+HAVE_FREETYPE	   = 0
+HAVE_RLAUNCH      = 0
+PERF_TEST		   = 0
+
+CONTENT_ID_FULL		= UP0001-SSNE10000_00-0000000000000001
+CONTENT_ID		= SSNE10000
+
+PC_DEVELOPMENT_IP_ADDRESS	= "192.168.1.7"
+PC_DEVELOPMENT_UDP_PORT		= 3490
+
+CELL_MK_DIR		?= $(CELL_SDK)/samples/mk
+include $(CELL_MK_DIR)/sdk.makedef.mk
+
+PPU_TARGET		= retroarch_ps3.elf
+SALAMANDER_TARGET	= retroarch-salamander_ps3.elf
+
+EBOOT_PATH		= ps3/pkg/USRDIR/EBOOT.BIN
+CORE_PATH		= ps3/pkg/USRDIR/cores/CORE.SELF
+
+LDDIRS = -L. -L$(CELL_SDK)/target/ppu/lib/PSGL/RSX/ultra-opt
+INCDIRS = -I. -Ips3 -Icommon
+
+# system platform
+system_platform = unix
+ifeq ($(shell uname -a),)
+EXE_EXT = .exe
+   system_platform = win
+else ifneq ($(findstring Darwin,$(shell uname -a)),)
+   system_platform = osx
+else ifneq ($(findstring MINGW,$(shell uname -a)),)
+   system_platform = win
+endif
+
+PKG_SCRIPT		= ps3/ps3py/pkg.py
+ifeq ($(shell uname), Linux)
+PKG_FINALIZE         	= package_finalize
+MAKE_SELF_WC		= make_self_wc
+MAKE_SELF		= make_self_npdrm
+PYTHON2			= python2
+GIT			= git
+else
+PKG_FINALIZE         	= package_finalize.exe
+MAKE_SELF_WC		= make_self_wc.exe
+MAKE_SELF		= make_self_npdrm.exe
+PYTHON2			= python2.exe
+GIT			= git.exe
+endif
+
+PPU_SRCS		= console/griffin/griffin.c
+
+ifeq ($(PERF_TEST), 1)
+   DEFINES += -DPERF_TEST
+endif
+
+ifeq ($(HAVE_RLAUNCH), 1)
+	DEFINES += -DHAVE_RLAUNCH
+endif
+
+ifeq ($(HAVE_RGL), 1)
+DEFINES			+= -DHAVE_RGL
+GL_LIBS			:= -L. -lrgl_ps3
+else
+GL_LIBS			:= -L$(CELL_SDK)/target/ppu/lib/PSGL/RSX/ultra-opt -lPSGL -lPSGLcgc
+endif
+
+ifeq ($(HAVE_FREETYPE), 1)
+DEFINES			+= -DHAVE_FREETYPE
+FONT_LIBS		:= -lfontFT_stub -lfreetype_stub
+else
+DEFINES			+= -DHAVE_LIBDBGFONT
+FONT_LIBS		:= -ldbgfont
+endif
+
+ifeq ($(CELL_BUILD_TOOLS), SNC)
+	PPU_CXXLD = $(CELL_SDK)/host-win32/sn/bin/ps3ppuld.exe
+	PPU_CXX	= $(CELL_SDK)/host-win32/sn/bin/ps3ppusnc.exe
+	PPU_CC = $(CELL_SDK)/host-win32/sn/bin/ps3ppusnc.exe
+else
+ifneq($(system_platform), win)
+	PPU_CXX	= $(CELL_SDK)/host-win32/ppu/bin/ppu-lv2-g++.exe
+	PPU_CC = $(CELL_SDK)/host-win32/ppu/bin/ppu-lv2-gcc.exe
+	PPU_CXXLD = $(CELL_SDK)/host-win32/ppu/bin/ppu-lv2-ld.exe
+	PPU_CCLD = $(CELL_SDK)/host-win32/ppu/bin/ppu-lv2-ld.exe
+endif
+
+PPU_LDLIBS =  $(FONT_LIBS) $(GL_LIBS) -lretro_ps3 -lcgc -lgcm_cmdasm -lgcm_sys_stub -lresc_stub -lm -lio_stub -lfs_stub -lsysutil_stub -lsysutil_game_stub -lsysutil_screenshot_stub -lsysutil_np_stub -lpngdec_stub -ljpgdec_stub -lsysmodule_stub -laudio_stub -lnet_stub -lnetctl_stub -lpthread
+
+PPU_RANLIB = $(CELL_SDK)/host-win32/ppu/bin/ppu-lv2-ranlib.exe
+
+DEFINES += -DHAVE_DEFAULT_RETROPAD_INPUT -DHAVE_RMENU -DHAVE_RMENU_GUI -DHAVE_THREAD -DRARCH_CONSOLE -DHAVE_OPENGL -DHAVE_HEADSET -DHAVE_VID_CONTEXT -DHAVE_OPENGLES -DHAVE_OPENGLES1 -DHAVE_PSGL -DHAVE_CG -DHAVE_CG_RUNTIME_COMPILER -DHAVE_FILEBROWSER -DHAVE_FBO -DHAVE_RARCH_MAIN_WRAP -DHAVE_SYSMODULES -DHAVE_SYSUTILS -DHAVE_RARCH_EXEC -DHAVE_LIBRETRO_MANAGEMENT -DHAVE_RSOUND -DHAVE_ZLIB -DWANT_RZLIB -D__CELLOS_LV2__ -DHAVE_NETPLAY=1 -DHAVE_SOCKET_LEGACY=1 -DHAVE_OSKUTIL -DHAVE_MOUSE -DHAVE_GRIFFIN=1 -DHAVE_MULTIMAN=1 -DPACKAGE_VERSION=\"$(RARCH_VERSION)\" -Dmain=rarch_main -DPC_DEVELOPMENT_IP_ADDRESS=\"$(PC_DEVELOPMENT_IP_ADDRESS)\" -DPC_DEVELOPMENT_UDP_PORT=$(PC_DEVELOPMENT_UDP_PORT)
+
+ifeq ($(DEBUG), 1)
+   PPU_OPTIMIZE_LV	:= -O0 -g
+else
+   PPU_OPTIMIZE_LV	:= -O3 -g
+endif
+
+ifeq ($(HAVE_LOGGER), 1)
+DEFINES			+= -DHAVE_LOGGER
+INCDIRS        +=  -Iconsole/logger
+endif
+
+PPU_CFLAGS := $(PPU_OPTIMIZE_LV) $(INCDIRS) $(DEFINES)
+PPU_CXXFLAGS := $(PPU_OPTIMIZE_LV) $(INCDIRS) $(DEFINES)
+
+EXIST_EBOOT_WILDCARD := $(wildcard $(EBOOT_PATH))
+EXIST_CORE_WILDCARD := $(wildcard $(CORE_PATH))
+
+EBOOT_EXISTS		= 1
+CORE_EXISTS		= 1
+
+ifneq ($(strip $(EXIST_EBOOT_WILDCARD)),)
+EBOOT_EXISTS		= 0
+endif
+
+ifneq ($(strip $(EXIST_CORE_WILDCARD)),)
+CORE_EXISTS		= 0
+endif
+
+include $(CELL_MK_DIR)/sdk.target.mk
+
+MAKE_FSELF = $(CELL_SDK)/host-win32/bin/make_fself.exe
+MAKE_FSELF_NPDRM = $(CELL_SDK)/host-win32/bin/make_fself_npdrm.exe
+MAKE_PACKAGE_NPDRM = $(CELL_SDK)/host-win32/bin/make_package_npdrm.exe
+
+.PHONY: create-npdrm-core create-core create-npdrm-salamander create-shaders clean-selfs create-salamander
+
+create-npdrm-core:
+	$(MAKE_FSELF_NPDRM) $(PPU_TARGET) $(CORE_PATH)
+
+create-core:
+	$(MAKE_SELF_WC) $(PPU_TARGET) $(CORE_PATH)
+
+create-npdrm-salamander:
+	$(MAKE_FSELF_NPDRM) $(SALAMANDER_TARGET) $(EBOOT_PATH)
+	
+create-salamander:
+	$(MAKE_SELF) $(SALAMANDER_TARGET) $(EBOOT_PATH) $(CONTENT_ID_FULL)
+
+copy-media-files:
+	@cp $(RMENU_IMG_DIR)/main-menu_1080p.png ps3/pkg/USRDIR/cores/borders/Menu/main-menu.png
+
+create-shaders:
+	make -f Makefile.shaders deploy-ps3
+
+pkg: $(PPU_TARGET)  create-shaders copy-media-files create-npdrm-salamander create-npdrm-core
+	$(MAKE_PACKAGE_NPDRM) ps3/pkg/package.conf ps3/pkg
+
+pkg-signed: $(PPU_TARGET)  create-shaders copy-media-files create-salamander create-core
+	$(PYTHON2) $(PKG_SCRIPT) --contentid $(CONTENT_ID_FULL) ps3/pkg/ retroarch-ps3-cfw-$(RARCH_VERSION).pkg
+
+pkg-signed-standalone: $(PPU_TARGET)  create-shaders copy-media-files create-core
+	$(MAKE_SELF) $(PPU_TARGET) $(EBOOT_PATH) $(CONTENT_ID)
+	$(PYTHON2) $(PKG_SCRIPT) --contentid $(CONTENT_ID_FULL) ps3/pkg/ retroarch-ps3-cfw-$(RARCH_VERSION).pkg
+
+pkg-signed-cfw: $(PPU_TARGET)  create-shaders copy-media-files create-salamander create-core
+	$(PYTHON2) $(PKG_SCRIPT) --contentid $(CONTENT_ID_FULL) ps3/pkg/ retroarch-ps3-cfw-$(RARCH_VERSION)-kmeaw.pkg
+	$(PKG_FINALIZE) retroarch-ps3-cfw-$(RARCH_VERSION)-kmeaw.pkg
+
+pkg-signed-cfw-standalone: $(PPU_TARGET)  create-shaders copy-media-files create-core
+	$(MAKE_SELF) $(PPU_TARGET) $(EBOOT_PATH) $(CONTENT_ID)
+	$(PYTHON2) $(PKG_SCRIPT) --contentid $(CONTENT_ID_FULL) ps3/pkg/ retroarch-ps3-cfw-$(RARCH_VERSION).pkg
+	$(PKG_FINALIZE) retroarch-ps3-cfw-$(RARCH_VERSION)-kmeaw.pkg
+
+clean-selfs:
+ifeq ($(EBOOT_EXISTS),1)
+	@echo "WARNING: Couldn't find file to delete: [$(EBOOT_PATH)], skipping this step."
+else
+	rm $(EBOOT_PATH)
+endif
+ifeq ($(CORE_EXISTS),1)
+	@echo "WARNING: Couldn't find file to delete: [$(CORE_PATH)], skipping this step."
+else
+	rm $(CORE_PATH)
+endif

Makefile.ps3.rgl

@@ -0,0 +1,65 @@
+#which compiler to build  with - GCC or SNC
+#set to GCC for debug builds for use with debugger
+CELL_BUILD_TOOLS	= GCC
+CELL_GPU_TYPE	   	= RSX
+
+DEBUG			= 0
+STRIPPING_ENABLE	=  1
+RGL_2D      = 1
+
+PC_DEVELOPMENT_IP_ADDRESS	= "192.168.1.7"
+PC_DEVELOPMENT_UDP_PORT		= 3490
+
+CELL_MK_DIR		?= $(CELL_SDK)/samples/mk
+include $(CELL_MK_DIR)/sdk.makedef.mk
+
+PPU_LIB_TARGET		= librgl_ps3.a
+
+LDDIRS = -L.
+INCDIRS = -I. -Iconsole/rgl/include
+
+RGL_DIR = console/rgl/src
+
+PPU_SRCS		=  $(RGL_DIR)/Utils/NameSpace.cpp \
+			  $(RGL_DIR)/Utils/TexNameSpace.cpp \
+			  $(RGL_DIR)/Utils/EnumMap.cpp \
+			  $(RGL_DIR)/libelf/readelf.cpp \
+			  $(RGL_DIR)/rgl.cpp \
+			  $(RGL_DIR)/rgl_cg.cpp \
+			  $(RGL_DIR)/ps3/rgl_ps3.cpp \
+			  $(RGL_DIR)/ps3/rgl_ps3_raster.cpp 
+
+
+ifeq ($(CELL_BUILD_TOOLS), SNC)
+	PPU_CXXLD = $(CELL_SDK)/host-win32/sn/bin/ps3ppuld.exe
+	PPU_CXX	= $(CELL_SDK)/host-win32/sn/bin/ps3ppusnc.exe
+	PPU_CC = $(CELL_SDK)/host-win32/sn/bin/ps3ppusnc.exe
+	SNC_PPU_AR = $(CELL_SDK)/host-win32/sn/bin/ps3snarl.exe
+else
+	PPU_CXX	= $(CELL_SDK)/host-win32/ppu/bin/ppu-lv2-g++.exe
+	PPU_CC = $(CELL_SDK)/host-win32/ppu/bin/ppu-lv2-gcc.exe
+	PPU_CXXLD = $(CELL_SDK)/host-win32/ppu/bin/ppu-lv2-ld.exe
+	PPU_AR = $(CELL_SDK)/host-win32/ppu/bin/ppu-lv2-ar.exe
+endif
+
+PPU_RANLIB = $(CELL_SDK)/host-win32/ppu/bin/ppu-lv2-ranlib.exe
+
+
+PPU_LDLIBS = -lio_stub 
+
+DEFINES += -D__CELLOS_LV2__
+
+ifeq ($(DEBUG), 1)
+   PPU_OPTIMIZE_LV	:= -O0 -g
+else
+   PPU_OPTIMIZE_LV	:= -O3
+endif
+
+ifeq ($(RGL_2D), 1)
+	PPU_OPTIMIZE_LV += -DHAVE_RGL_2D
+endif
+
+PPU_CFLAGS = $(PPU_OPTIMIZE_LV) $(INCDIRS) $(DEFINES)
+PPU_CXXFLAGS = $(PPU_OPTIMIZE_LV) $(INCDIRS) $(DEFINES)
+
+include $(CELL_MK_DIR)/sdk.target.mk

Makefile.ps3.salamander

@@ -0,0 +1,50 @@
+CELL_BUILD_TOOLS	= SNC
+CELL_SDK		?= /usr/local/cell
+HAVE_LOGGER		= 0
+CELL_MK_DIR ?= $(CELL_SDK)/samples/mk
+
+include $(CELL_MK_DIR)/sdk.makedef.mk
+
+# system platform
+system_platform = unix
+ifeq ($(shell uname -a),)
+EXE_EXT = .exe
+   system_platform = win
+else ifneq ($(findstring Darwin,$(shell uname -a)),)
+   system_platform = osx
+else ifneq ($(findstring MINGW,$(shell uname -a)),)
+   system_platform = win
+endif
+
+STRIP			= $(CELL_SDK)/host-win32/ppu/bin/ppu-lv2-strip.exe
+
+PPU_CFLAGS		+= -I. -D__CELLOS_LV2__ -DIS_SALAMANDER -DRARCH_CONSOLE -DHAVE_SYSUTILS -DHAVE_SYSMODULES -DHAVE_RARCH_EXEC
+PPU_SRCS		= frontend/frontend_console.c file_path.c compat/compat.c conf/config_file.c
+
+ifeq ($(HAVE_LOGGER), 1)
+PPU_CFLAGS		+= -DHAVE_LOGGER -Iconsole/logger
+PPU_SRCS		+= console/logger/logger.c
+endif
+
+PPU_TARGET		= retroarch-salamander_ps3.elf
+
+ifeq ($(CELL_BUILD_TOOLS),SNC)
+	PPU_CFLAGS		+= -Xbranchless=1 -Xfastmath=1 -Xassumecorrectsign=1 -Xassumecorrectalignment=1 -Xunroll=1 -Xautovecreg=1 
+	PPU_CXXFLAGS		+= -Xbranchless=1 -Xfastmath=1 -Xassumecorrectsign=1 -Xassumecorrectalignment=1 -Xunroll=1 -Xautovecreg=1
+	PPU_CXXLD = $(CELL_SDK)/host-win32/sn/bin/ps3ppuld.exe
+	PPU_CLD = $(CELL_SDK)/host-win32/sn/bin/ps3ppuld.exe
+	PPU_CC = $(CELL_SDK)/host-win32/sn/bin/ps3ppusnc.exe
+else
+	PPU_CFLAGS += -std=gnu99
+	PPU_CC = $(CELL_SDK)/host-win32/ppu/bin/ppu-lv2-gcc.exe
+	PPU_CLD = $(CELL_SDK)/host-win32/ppu/bin/ppu-lv2-ld.exe
+	PPU_CXXLD = $(CELL_SDK)/host-win32/sn/bin/ps3ppuld.exe
+endif
+
+PPU_LDLIBS		+= -lm -lnet_stub -lnetctl_stub -lio_stub -lsysmodule_stub -lsysutil_stub -lsysutil_game_stub -lfs_stub -lsysutil_np_stub
+
+PPU_OPTIMIZE_LV		:= -O2
+
+MAKE_FSELF = $(CELL_SDK)/host-win32/bin/make_fself.exe
+
+include $(CELL_MK_DIR)/sdk.target.mk

Makefile.psl1ght

@@ -0,0 +1,138 @@
+###
+##
+# Makefile for RetroArch PSL1GHT.
+##
+RARCH_VERSION		= "0.9.8"
+
+DEBUG			= 0
+HAVE_LOGGER		= 0
+HAVE_FILE_LOGGER	= 0
+
+PC_DEVELOPMENT_IP_ADDRESS	= "192.168.1.7"
+PC_DEVELOPMENT_UDP_PORT		= 3490
+
+CC = $(PS3DEV)/ppu/bin/ppu-gcc
+CXX = $(PS3DEV)/ppu/bin/ppu-g++
+LD = $(PS3DEV)/ppu/bin/ppu-ld
+
+CONTENT_ID_FULL		= UP0001-SSNE10000_00-0000000000000001
+
+ELF_TARGET := retroarch_psl1ght.elf
+EBOOT_PATH		= ps3/pkg/USRDIR/EBOOT.BIN
+CORE_PATH		= ps3/pkg/USRDIR/cores/CORE.SELF
+
+INCLUDE := -I. -I$(PS3DEV)/ppu/include
+LIBDIRS := -L$(PS3DEV)/ppu/lib -L$(PS3DEV)/portlibs/ppu/lib -L.
+
+MACHDEP := -D__CELLOS_LV2__ -D__PSL1GHT__
+CFLAGS += -Wall $(MACHDEP) $(INCLUDE)
+LDFLAGS := $(MACHDEP)
+LIBS := -lretro_psl1ght -laudio -lGL -lEGL -lrsx -lgcm_sys -lnet -lio -lsysutil -lsysmodule  -lm -ljpgdec -lpngdec -llv2 -lnet -lnetctl
+
+# system platform
+system_platform = unix
+ifeq ($(shell uname -a),)
+EXE_EXT = .exe
+   system_platform = win
+else ifneq ($(findstring Darwin,$(shell uname -a)),)
+   system_platform = osx
+else ifneq ($(findstring MINGW,$(shell uname -a)),)
+   system_platform = win
+endif
+
+PKG_SCRIPT		= ps3/ps3py/pkg.py
+ifeq ($(shell uname), Linux)
+PKG_FINALIZE         	= package_finalize
+MAKE_SELF_WC		= make_self_wc
+MAKE_SELF		= make_self_npdrm
+PYTHON2			= python2
+GIT			= git
+else
+PKG_FINALIZE         	= package_finalize.exe
+MAKE_SELF_WC		= make_self_wc.exe
+MAKE_SELF		= make_self_npdrm.exe
+PYTHON2			= python2.exe
+GIT			= git.exe
+endif
+# system platform
+system_platform = unix
+ifeq ($(shell uname -a),)
+EXE_EXT = .exe
+   system_platform = win
+else ifneq ($(findstring Darwin,$(shell uname -a)),)
+   system_platform = osx
+else ifneq ($(findstring MINGW,$(shell uname -a)),)
+   system_platform = win
+endif
+
+PKG_SCRIPT		= ps3/ps3py/pkg.py
+ifeq ($(shell uname), Linux)
+PKG_FINALIZE         	= package_finalize
+MAKE_SELF_WC		= make_self_wc
+MAKE_SELF		= make_self_npdrm
+PYTHON2			= python2
+GIT			= git
+else
+PKG_FINALIZE         	= package_finalize.exe
+MAKE_SELF_WC		= make_self_wc.exe
+MAKE_SELF		= make_self_npdrm.exe
+PYTHON2			= python2.exe
+GIT			= git.exe
+endif
+
+MAKE_FSELF_NPDRM = $(CELL_SDK)/host-win32/bin/make_fself_npdrm.exe
+MAKE_PACKAGE_NPDRM = $(CELL_SDK)/host-win32/bin/make_package_npdrm.exe
+
+OBJ = console/griffin/griffin.o
+
+ifeq ($(HAVE_LOGGER), 1)
+CFLAGS		+= -DHAVE_LOGGER
+CFLAGS		+= -Iconsole/logger
+endif
+
+ifeq ($(HAVE_FILE_LOGGER), 1)
+CFLAGS		+= -DHAVE_FILE_LOGGER
+endif
+
+RSXGL_DEFINES = -D__RSX__ -DGL3_PROTOTYPES
+
+SHARED_FLAGS := -DHAVE_FILEBROWSER $(RSXGL_DEFINES) -DHAVE_OPENGL -DHAVE_EGL -DHAVE_OPENGL_MODERN -DHAVE_GLSL -DHAVE_VID_CONTEXT -DHAVE_FBO -DHAVE_MOUSE -DHAVE_DEFAULT_RETROPAD_INPUT -DRARCH_CONSOLE -DHAVE_ZLIB -DWANT_RZLIB -DHAVE_RARCH_MAIN_WRAP -DHAVE_SYSMODULES -DHAVE_SYSUTILS -DHAVE_GRIFFIN=1 -DHAVE_NETPLAY=1 -DHAVE_SOCKET_LEGACY=1 -DPACKAGE_VERSION=\"0.9.8\" -Dmain=rarch_main -DPC_DEVELOPMENT_IP_ADDRESS=\"$(PC_DEVELOPMENT_IP_ADDRESS)\" -DPC_DEVELOPMENT_UDP_PORT=$(PC_DEVELOPMENT_UDP_PORT) -Wno-char-subscripts
+CFLAGS += -std=gnu99 $(SHARED_FLAGS)
+CXXFLAGS += $(SHARED_FLAGS)
+
+ifeq ($(DEBUG), 1)
+   CFLAGS += -O0 -g
+else
+   CFLAGS += -O3 -g 
+   CXXFLAGS += -03 -g
+endif
+
+all: $(ELF_TARGET)
+
+$(ELF_TARGET): $(OBJ)
+	$(CXX) -o $@ $(LDFLAGS) $(LIBDIRS) $(OBJ) $(LIBS)
+
+%.o: %.c
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+%.o: %.cpp
+	$(CXX) $(CFLAGS) -c -o $@ $<
+
+create-npdrm-core:
+	$(MAKE_FSELF_NPDRM) $(ELF_TARGET) $(CORE_PATH)
+
+create-core:
+	$(MAKE_SELF_WC) $(ELF_TARGET) $(CORE_PATH)
+
+pkg: $(ELF_TARGET) create-npdrm-core
+	$(MAKE_PACKAGE_NPDRM) ps3/pkg/package.conf ps3/pkg
+
+pkg-signed: $(ELF_TARGET) create-core
+	$(PYTHON2) $(PKG_SCRIPT) --contentid $(CONTENT_ID_FULL) ps3/pkg/ retroarch-ps3-cfw-$(RARCH_VERSION).pkg
+
+clean:
+	rm -f $(ELF_TARGET)
+	rm -f $(OBJ)
+
+.PHONY: clean
+

Makefile.psp1

@@ -0,0 +1,31 @@
+RARCH_VERSION		= "0.9.8"
+
+HAVE_FILE_LOGGER	= 1
+
+TARGET = retroarchpsp
+
+INCDIR = 
+CFLAGS = -O2 -G0 -g -std=gnu99 -ffast-math
+ASFLAGS = $(CFLAGS)
+
+RARCH_DEFINES = -DPSP -DHAVE_DEFAULT_RETROPAD_INPUT -DHAVE_FILEBROWSER -DHAVE_RARCH_MAIN_WRAP -DHAVE_LIBRETRO_MANAGEMENT -DHAVE_ZLIB -DWANT_RZLIB -DHAVE_GRIFFIN=1 -DPACKAGE_VERSION=\"$(RARCH_VERSION)\" -Dmain=rarch_main -DHAVE_NULLVIDEO -DHAVE_NULLAUDIO -DHAVE_RMENU
+
+ifeq ($(HAVE_FILE_LOGGER), 1)
+CFLAGS		+= -DHAVE_FILE_LOGGER
+endif
+
+CFLAGS += $(RARCH_DEFINES)
+
+LIBDIR =
+LDFLAGS =
+LIBS = -lretro_psp1 -lstdc++ -lpspgu -lpspgum -lm
+
+EXTRA_TARGETS = EBOOT.PBP
+PSP_EBOOT_TITLE = RetroArch PSP1
+
+PSP_OBJECTS = console/griffin/griffin.o
+
+OBJS = $(PSP_OBJECTS)
+
+PSPSDK=$(shell psp-config --pspsdk-path)
+include $(PSPSDK)/lib/build.mak

Makefile.shaders

@@ -0,0 +1,51 @@
+DOWNLOAD_SHADERS	= 1
+SHADER_DIR     := media/shaders
+SHADER_XML_DIR := media/shaders_xml
+
+SHADER_DEST_PS3_DIR := ps3/pkg/USRDIR/cores/shaders
+
+# system platform
+system_platform = unix
+ifeq ($(shell uname -a),)
+EXE_EXT = .exe
+   system_platform = win
+else ifneq ($(findstring Darwin,$(shell uname -a)),)
+   system_platform = osx
+else ifneq ($(findstring MINGW,$(shell uname -a)),)
+   system_platform = win
+endif
+
+ifeq ($(shell uname), Linux)
+PYTHON2		= python2
+PYTHON3		= python
+GIT			= git
+else
+PYTHON2		= python2.exe
+PYTHON3		= python.exe
+GIT			= git.exe
+endif
+
+checkout-shaders:
+ifeq ($(DOWNLOAD_SHADERS),1)
+	@if test -d $(SHADER_DIR); then \
+		echo "[SHADER CHECKOUT::] Git pulling common-shaders..."; \
+      cd $(SHADER_DIR); \
+		$(GIT) pull; \
+		cd ../../../../..; \
+	else \
+	echo "[SHADER CHECKOUT::] Git cloning common-shaders first..."; \
+      $(GIT) clone git://github.com/libretro/common-shaders.git $(SHADER_DIR); \
+	fi
+endif
+
+convert-xml:
+	$(PYTHON) tools/cg2xml.py $(SHADER_DIR) $(SHADER_XML_DIR)
+
+deploy-ps3: checkout-shaders
+	@if test -d $(SHADER_DEST_PS3_DIR); then \
+		cp -r $(SHADER_DIR)/* $(SHADER_DEST_PS3_DIR); \
+	else \
+	echo "[DEPLOY PS3::] Creating PS3 shader directory first..."; \
+		mkdir -p $(SHADER_DEST_PS3_DIR) || bin/true; \
+	fi
+	@echo "[DEPLOY PS3::] Copied shaders to PS3 shaders directory."

Makefile.wii

@@ -0,0 +1,105 @@
+###
+##
+# Makefile for RetroArch Wii.
+##
+
+DEBUG			= 0
+HAVE_LOGGER		= 0
+HAVE_FILE_LOGGER	= 0
+PERF_TEST		= 0
+HAVE_WIIUSE_MOD = 1
+
+PC_DEVELOPMENT_IP_ADDRESS	= "192.168.1.100"
+PC_DEVELOPMENT_UDP_PORT		= 3490
+
+# system platform
+system_platform = unix
+ifeq ($(shell uname -a),)
+EXE_EXT = .exe
+   system_platform = win
+else ifneq ($(findstring Darwin,$(shell uname -a)),)
+   system_platform = osx
+else ifneq ($(findstring MINGW,$(shell uname -a)),)
+   system_platform = win
+endif
+
+ifeq ($(HAVE_WIIUSE_MOD), 1)
+CFLAGS += -DHAVE_WIIUSE
+else
+LDFLAGS_WIIUSE := -lwiiuse
+endif
+
+CC = $(DEVKITPPC)/bin/powerpc-eabi-gcc$(EXE_EXT)
+CXX = $(DEVKITPPC)/bin/powerpc-eabi-g++$(EXE_EXT)
+LD = $(DEVKITPPC)/bin/powerpc-eabi-ld$(EXE_EXT)
+ELF2DOL = $(DEVKITPPC)/bin/elf2dol$(EXE_EXT)
+
+DOL_TARGET := retroarch_wii.dol
+ELF_TARGET := retroarch_wii.elf
+
+INCLUDE := -I. -I$(DEVKITPRO)/libogc/include -I$(DEVKITPRO)/libogc/include/ogc
+LIBDIRS := -L$(DEVKITPRO)/libogc/lib/wii -L.
+
+MACHDEP := -DGEKKO -DHW_RVL -mrvl -mcpu=750 -meabi -mhard-float
+CFLAGS += -Wall -std=gnu99 $(MACHDEP) $(INCLUDE)
+LDFLAGS := $(MACHDEP) -Wl,-Map,$(notdir $(ELF_TARGET)).map,-wrap,malloc,-wrap,free,-wrap,memalign,-wrap,calloc,-wrap,realloc,-wrap,strdup,-wrap,strndup,-wrap,malloc_usable_size -T gx/ld/rvl.ld
+LIBS := -lfat -lretro_wii -logc $(LDFLAGS_WIIUSE) -lbte 
+APP_BOOTER_DIR = wii/app_booter
+
+OBJ = console/griffin/griffin.o $(APP_BOOTER_DIR)/app_booter.binobj
+
+ifeq ($(PERF_TEST), 1)
+   CFLAGS += -DPERF_TEST
+endif
+
+ifeq ($(HAVE_LOGGER), 1)
+CFLAGS		+= -DHAVE_LOGGER
+CFLAGS          += -DPC_DEVELOPMENT_IP_ADDRESS=\"$(PC_DEVELOPMENT_IP_ADDRESS)\" -DPC_DEVELOPMENT_UDP_PORT=$(PC_DEVELOPMENT_UDP_PORT)
+CFLAGS          += -Iconsole/logger
+endif
+
+ifeq ($(HAVE_FILE_LOGGER), 1)
+CFLAGS		+= -DHAVE_FILE_LOGGER
+CFLAGS          += -Iconsole/logger
+endif
+
+
+CFLAGS += -std=gnu99 -DHAVE_DEFAULT_RETROPAD_INPUT -DHAVE_RGUI -DHAVE_THREAD -DRARCH_CONSOLE -DHAVE_LIBRETRO_MANAGEMENT -DHAVE_RARCH_EXEC -DHAVE_RMENU -DGEKKO -DHAVE_ZLIB -DWANT_RZLIB -DHAVE_RARCH_MAIN_WRAP -DHAVE_GRIFFIN=1 -DHAVE_SCREENSHOTS -DPACKAGE_VERSION=\"0.9.8\" -Dmain=rarch_main -Wno-char-subscripts 
+
+ifeq ($(DEBUG), 1)
+   CFLAGS += -O0 -g -DDEBUG
+else
+   CFLAGS += -O3
+endif
+
+all: $(DOL_TARGET)
+
+%.dol: %.elf
+	$(ELF2DOL) $< $@
+
+$(ELF_TARGET): $(OBJ)
+	$(CXX) -o $@ $(LDFLAGS) $(LIBDIRS) $(OBJ) $(LIBS)
+
+%.o: %.c
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+%.bmpobj: %.bmp
+	$(LD) -r -b binary -o $@ $<
+
+%.binobj: %.bin
+	$(LD) -r -b binary -o $@ $<
+
+$(APP_BOOTER_DIR)/app_booter.bin:
+	$(MAKE) -C $(APP_BOOTER_DIR)
+
+pkg: all
+	cp -r $(DOL_TARGET) wii/pkg/CORE.dol
+
+clean:
+	rm -f $(DOL_TARGET)
+	rm -f $(ELF_TARGET)
+	rm -f $(OBJ)
+	$(MAKE) -C $(APP_BOOTER_DIR) clean
+
+.PHONY: clean
+

Makefile.wii.salamander

@@ -0,0 +1,91 @@
+###
+##
+# Makefile for RetroArch Wii.
+##
+
+DEBUG			= 0
+HAVE_LOGGER		= 0
+HAVE_FILE_LOGGER	= 0
+
+# system platform
+system_platform = unix
+ifeq ($(shell uname -a),)
+EXE_EXT = .exe
+   system_platform = win
+else ifneq ($(findstring Darwin,$(shell uname -a)),)
+   system_platform = osx
+else ifneq ($(findstring MINGW,$(shell uname -a)),)
+   system_platform = win
+endif
+
+PC_DEVELOPMENT_IP_ADDRESS	= "192.168.1.7"
+PC_DEVELOPMENT_UDP_PORT		= 3490
+
+CC = $(DEVKITPPC)/bin/powerpc-eabi-gcc$(EXE_EXT)
+CXX = $(DEVKITPPC)/bin/powerpc-eabi-g++$(EXE_EXT)
+LD = $(DEVKITPPC)/bin/powerpc-eabi-ld$(EXE_EXT)
+ELF2DOL = $(DEVKITPPC)/bin/elf2dol$(EXE_EXT)
+
+DOL_TARGET := retroarch-salamander_wii.dol
+ELF_TARGET := retroarch-salamander_wii.elf
+
+INCLUDE := -I. -I$(DEVKITPRO)/libogc/include
+LIBDIRS := -L$(DEVKITPRO)/libogc/lib/wii -L.
+
+MACHDEP := -DGEKKO -DHW_RVL -mrvl -mcpu=750 -meabi -mhard-float
+CFLAGS += -Wall -std=gnu99 $(MACHDEP) $(INCLUDE)
+LDFLAGS := $(MACHDEP) -Wl,-Map,$(notdir $(ELF_TARGET)).map
+LIBS := -lfat -lwiiuse -logc -lbte
+
+APP_BOOTER_DIR = wii/app_booter
+
+OBJ = frontend/frontend_console.o file_path.o compat/compat.o conf/config_file.o $(APP_BOOTER_DIR)/app_booter.binobj
+
+ifeq ($(HAVE_LOGGER), 1)
+CFLAGS		+= -DHAVE_LOGGER
+CFLAGS          += -DPC_DEVELOPMENT_IP_ADDRESS=\"$(PC_DEVELOPMENT_IP_ADDRESS)\" -DPC_DEVELOPMENT_UDP_PORT=$(PC_DEVELOPMENT_UDP_PORT)
+CFLAGS          += -Iconsole/logger
+OBJ             += console/logger/logger.o
+endif
+
+ifeq ($(HAVE_FILE_LOGGER), 1)
+CFLAGS		+= -DHAVE_FILE_LOGGER
+CFLAGS          += -Iconsole/logger
+endif
+
+CFLAGS += -std=gnu99 -DHAVE_DEFAULT_RETROPAD_INPUT -DIS_SALAMANDER -DRARCH_CONSOLE -DHAVE_RARCH_EXEC -DGEKKO -DPACKAGE_VERSION=\"0.9.8\" -Wno-char-subscripts 
+
+ifeq ($(DEBUG), 1)
+   CFLAGS += -O0 -g
+else
+   CFLAGS += -O3
+endif
+
+all: $(DOL_TARGET)
+
+%.dol: %.elf
+	$(ELF2DOL) $< $@
+
+$(ELF_TARGET): $(OBJ)
+	$(CXX) -o $@ $(LDFLAGS) $(LIBDIRS) $(OBJ) $(LIBS)
+
+%.o: %.c
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+%.binobj: %.bin
+	$(LD) -r -b binary -o $@ $<
+
+$(APP_BOOTER_DIR)/app_booter.bin:
+	$(MAKE) -C $(APP_BOOTER_DIR)
+
+pkg: all
+	cp -r $(DOL_TARGET) wii/pkg/boot.dol
+
+clean:
+	rm -f $(DOL_TARGET)
+	rm -f $(ELF_TARGET)
+	rm -f $(OBJ)
+	$(MAKE) -C $(APP_BOOTER_DIR) clean
+
+.PHONY: clean
+

Makefile.win

@@ -0,0 +1,301 @@
+TARGET = retroarch.exe
+JTARGET = tools/retroarch-joyconfig.exe
+
+OBJ = retroarch.o \
+		file.o \
+		file_path.o \
+		driver.o \
+		conf/config_file.o \
+		settings.o \
+		hash.o \
+		dynamic.o \
+		message.o \
+		rewind.o \
+		movie.o \
+		gfx/gfx_common.o \
+		input/input_common.o \
+		patch.o \
+		compat/compat.o \
+		screenshot.o \
+		cheats.o \
+		audio/utils.o \
+		input/overlay.o \
+		fifo_buffer.o \
+		media/rarch.o \
+		gfx/scaler/scaler.o \
+		gfx/scaler/pixconv.o \
+		gfx/scaler/scaler_int.o \
+		gfx/scaler/filter.o \
+		gfx/state_tracker.o \
+		gfx/fonts/fonts.o \
+		gfx/fonts/bitmapfont.o \
+		gfx/image.o \
+		performance.o
+
+JOBJ := conf/config_file.o \
+	tools/retroarch-joyconfig.o \
+	compat/compat.o \
+	file_path.o \
+	input/input_common.o \
+	input/dinput.o
+
+CC = gcc
+CXX = g++
+WINDRES = windres
+
+HAVE_DINPUT = 1
+HAVE_XAUDIO = 1
+HAVE_DSOUND = 1
+HAVE_OPENGL = 1
+HAVE_DYLIB = 1
+HAVE_D3D9 = 1
+HAVE_NETPLAY = 1
+HAVE_STDIN_CMD = 1
+HAVE_THREADS = 1
+HAVE_SINC = 1
+DYNAMIC = 1
+
+ifeq ($(SLIM),)
+   HAVE_SDL = 1
+   HAVE_SDL_IMAGE = 1
+   HAVE_LIBXML2 = 1
+   HAVE_FREETYPE = 1
+   HAVE_ZLIB = 1
+   HAVE_RSOUND = 1
+   HAVE_FBO = 1
+   HAVE_CG = 1
+   HAVE_PYTHON = 1
+   HAVE_FFMPEG = 1
+endif
+
+libretro ?= -lretro
+
+LIBS = -lm
+DEFINES = -I. -DHAVE_SCREENSHOTS -DHAVE_BSV_MOVIE -DPACKAGE_VERSION=\"0.9.8\"
+LDFLAGS = -L. -static-libgcc
+
+ifeq ($(TDM_GCC),)
+   LDCXXFLAGS += -static-libstdc++
+endif
+
+ifeq ($(SCALER_NO_SIMD), 1)
+   DEFINES += -DSCALER_NO_SIMD
+endif
+
+ifeq ($(PERF_TEST), 1)
+   DEFINES += -DPERF_TEST
+endif
+
+JLIBS =
+
+ifeq ($(HAVE_SDL), 1)
+   OBJ += gfx/sdl_gfx.o gfx/context/sdl_ctx.o input/sdl_input.o input/sdl_joypad.o audio/sdl_audio.o
+   JOBJ += input/sdl_joypad.o
+   LIBS += -lSDL
+   JLIBS += -lSDL
+   DEFINES += -ISDL -DHAVE_SDL
+endif
+
+ifeq ($(HAVE_THREADS), 1)
+   OBJ += autosave.o thread.o
+   DEFINES += -DHAVE_THREADS
+endif
+
+ifeq ($(HAVE_OPENGL), 1)
+   OBJ += gfx/gl.o gfx/math/matrix.o gfx/fonts/gl_font.o gfx/fonts/gl_raster_font.o gfx/gfx_context.o gfx/context/wgl_ctx.o gfx/shader_glsl.o 
+   DEFINES += -DHAVE_OPENGL -DHAVE_OVERLAY -DHAVE_GLSL
+   LIBS += -lopengl32 -lgdi32
+endif
+
+ifeq ($(HAVE_SDL_IMAGE), 1)
+   LIBS += -lSDL_image
+   DEFINES += -DHAVE_SDL_IMAGE
+endif
+
+ifeq ($(HAVE_CG), 1)
+   OBJ += gfx/shader_cg.o
+   LIBS += -lcg -lcgGL
+   DEFINES += -DHAVE_CG
+else
+   HAVE_D3D9 = 0
+endif
+
+ifeq ($(HAVE_D3D9), 1)
+   OBJ += gfx/d3d9/d3d9.o gfx/d3d9/render_chain.o
+   DEFINES += -DHAVE_WIN32_D3D9
+   LIBS += -ld3d9 -lcg -lcgD3D9 -ld3dx9 -ldxguid
+endif
+
+ifeq ($(HAVE_XAUDIO), 1)
+   OBJ += audio/xaudio.o audio/xaudio-c/xaudio-c.o
+   DEFINES += -DHAVE_XAUDIO
+   LIBS += -lole32
+endif
+
+ifeq ($(HAVE_DSOUND), 1)
+   OBJ += audio/dsound.o
+   DEFINES += -DHAVE_DSOUND
+   LIBS += -ldxguid -ldsound
+endif
+
+ifeq ($(HAVE_RSOUND), 1)
+   OBJ += audio/rsound.o
+   DEFINES += -DHAVE_RSOUND
+   LIBS += -lrsound
+endif
+
+ifeq ($(HAVE_ZLIB), 1)
+   OBJ += gfx/rpng/rpng.o file_extract.o
+   LIBS += -lz
+   DEFINES += -DHAVE_ZLIB_DEFLATE
+endif
+
+ifeq ($(HAVE_LIBXML2), 1)
+   DEFINES += -Ilibxml2 -DHAVE_LIBXML2 -DHAVE_GLSL
+   LIBS += -lxml2 -liconv
+else
+   OBJ += compat/rxml/rxml.o
+endif
+
+ifeq ($(HAVE_DYLIB), 1)
+   DEFINES += -DHAVE_DYLIB
+endif
+
+ifeq ($(HAVE_STDIN_CMD), 1)
+   DEFINES += -DHAVE_COMMAND -DHAVE_STDIN_CMD
+   OBJ += command.o
+endif
+
+ifeq ($(HAVE_NETPLAY), 1)
+   DEFINES += -DHAVE_NETPLAY -DHAVE_NETWORK_CMD
+   OBJ += netplay.o
+   LIBS += -lws2_32
+endif
+
+ifeq ($(HAVE_FREETYPE), 1)
+   OBJ += gfx/fonts/freetype.o
+   DEFINES += -DHAVE_FREETYPE -Ifreetype2
+   LIBS += -lfreetype -lz
+endif
+
+ifeq ($(DYNAMIC), 1)
+   DEFINES += -DHAVE_DYNAMIC
+else
+   LIBS += $(libretro)
+endif
+
+ifeq ($(HAVE_FBO), 1)
+   DEFINES += -DHAVE_FBO
+endif
+
+ifeq ($(HAVE_PYTHON), 1)
+   LIBS += -lpython32
+   DEFINES += -DHAVE_PYTHON -Ipython
+   OBJ += gfx/py_state/py_state.o
+endif
+
+ifeq ($(HAVE_DINPUT), 1)
+   LIBS += -ldinput8 -ldxguid -lole32
+   DEFINES += -DHAVE_DINPUT
+   OBJ += input/dinput.o
+endif
+
+ifeq ($(HAVE_FFMPEG), 1)
+   LIBS += -lavformat -lavcodec -lavutil -lswscale -lws2_32 -lz
+   DEFINES += -DHAVE_FFMPEG -Iffmpeg
+   OBJ += record/ffemu.o
+endif
+
+ifeq ($(HAVE_SINC), 1)
+   OBJ += audio/sinc.o
+else
+   OBJ += audio/hermite.o
+endif
+
+ifneq ($(V), 1)
+   Q := @
+endif
+
+ifeq ($(DEBUG), 1)
+   CFLAGS += -O0 -g
+   CXXFLAGS += -O0 -g
+else
+   CFLAGS += -O3
+   CXXFLAGS += -O3
+   LDCXXFLAGS += -s
+endif
+
+CFLAGS += -Wall -Wno-unused-result -I.
+CXXFLAGS += -Wall -Wno-unused-result -I. -std=c++0x -D__STDC_CONSTANT_MACROS
+ifeq ($(CXX_BUILD), 1)
+   CFLAGS += -std=c++0x -xc++ -D__STDC_CONSTANT_MACROS
+else
+   CFLAGS += -std=gnu99
+endif
+
+all: $(TARGET) $(JTARGET)
+
+$(TARGET): $(OBJ)
+	@$(if $(Q), $(shell echo echo LD $@),)
+	$(Q)$(CXX) -o $@ $(OBJ) $(LIBS) $(LDFLAGS) $(LDCXXFLAGS)
+
+%.o: %.c
+	@$(if $(Q), $(shell echo echo CC $<),)
+	$(Q)$(CC) $(CFLAGS) $(DEFINES) -c -o $@ $<
+
+%.o: %.cpp
+	@$(if $(Q), $(shell echo echo CXX $<),)
+	$(Q)$(CXX) $(CXXFLAGS) $(DEFINES) -c -o $@ $<
+
+%.o: %.rc
+	@$(if $(Q), $(shell echo echo WINDRES $<),)
+	$(Q)$(WINDRES) -o $@ $<
+
+$(JTARGET): $(JOBJ)
+	@$(if $(Q), $(shell echo echo LD $@),)
+ifeq ($(CXX_BUILD), 1)
+	$(Q)$(CXX) -o $@ $(JOBJ) -ldxguid -ldinput8 -lole32 $(LDFLAGS) $(JLIBS)
+else
+	$(Q)$(CC) -o $@ $(JOBJ) -ldxguid -ldinput8 -lole32 $(LDFLAGS) $(JLIBS)
+endif
+
+clean:
+	rm -f *.o 
+	rm -f audio/*.o
+	rm -f audio/xaudio-c/*.o
+	rm -f compat/*.o
+	rm -f compat/rxml/*.o
+	rm -f conf/*.o
+	rm -f gfx/scaler/*.o
+	rm -f gfx/*.o
+	rm -f gfx/d3d9/*.o
+	rm -f gfx/context/*.o
+	rm -f gfx/math/*.o
+	rm -f gfx/fonts/*.o
+	rm -f gfx/py_state/*.o
+	rm -f record/*.o
+	rm -f input/*.o
+	rm -f $(TARGET)
+	rm -f retroarch-joyconfig.exe
+	rm -f tools/*.o
+
+dist_x86: all
+	zip -r retroarch-win32-0.9.8.zip $(TARGET) $(JTARGET) retroarch.cfg
+
+dist_x86_64: all
+	zip -r retroarch-win64-0.9.8.zip $(TARGET) $(JTARGET) retroarch.cfg
+
+libs_x86:
+	wget https://github.com/downloads/Themaister/RetroArch/RetroArch-win32-libs.zip --no-check-certificate
+	unzip RetroArch-win32-libs.zip
+	wget https://github.com/downloads/Themaister/RetroArch/RetroArch-win32-headers.zip --no-check-certificate
+	unzip RetroArch-win32-headers.zip
+
+libs_x86_64:
+	wget https://github.com/downloads/Themaister/RetroArch/RetroArch-win64-libs.zip --no-check-certificate
+	unzip RetroArch-win64-libs.zip
+	wget https://github.com/downloads/Themaister/RetroArch/RetroArch-win64-headers.zip --no-check-certificate
+	unzip RetroArch-win64-headers.zip
+
+.PHONY: all install uninstall clean dist_x86 dist_x86_64 libs_x86 libs_x86_64
+

Makefile.win32

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

Makefile.xenon

@@ -0,0 +1,54 @@
+###
+##
+# Makefile for RetroArch libxenon.
+##
+###
+##
+
+DEBUG = 0
+
+CC = xenon-gcc
+CXX = xenon-g++
+OBJCOPY = xenon-objcopy
+STRIP = xenon-strip
+
+PPU_TARGET := retroarch-libxenon.elf
+PPU_TARGET_ADJUSTED := retroarch-libxenon.elf32
+
+LDDIRS = -L. -L$(DEVKITXENON)/usr/lib -L$(DEVKITXENON)/xenon/lib/32
+INCDIRS = -I. -I$(DEVKITXENON)/usr/include
+
+OBJ = console/griffin/griffin.o
+
+LIBS = -lretro_xenon360 -lxenon -lm -lc
+DEFINES = -std=gnu99 -DPACKAGE_VERSION=\"0.9.8\" -DRARCH_CONSOLE -DHAVE_THREAD -DHAVE_GETOPT_LONG=1 -DHAVE_GRIFFIN -Dmain=rarch_main
+DEFINES += -maltivec -mhard-float -m32 -mpowerpc64 -mcpu=cell -mtune=cell -fno-pic -g -Wall -DXENON $(INCDIRS) -Wno-char-subscripts
+DEFINES += -u read -u _start -u exc_base
+
+ifeq ($(DEBUG), 1)
+   OPTIMIZE_LV	:= -O0 -g
+else
+   OPTIMIZE_LV	:= -O3
+endif
+
+all: $(PPU_TARGET_ADJUSTED)
+
+CFLAGS := $(OPTIMIZE_LV) $(DEFINES)
+
+LDFLAGS := -m32 -n -T $(DEVKITXENON)/app.lds
+
+$(PPU_TARGET_ADJUSTED): $(PPU_TARGET)
+	$(OBJCOPY) -O elf32-powerpc --adjust-vma 0x80000000 $< $@
+	$(STRIP) $@
+
+$(PPU_TARGET): $(OBJ)
+	$(CXX) -o $@ $(OBJ) $(LDFLAGS) $(LDDIRS) $(LIBS)
+
+%.o: %.c config.h
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+clean:
+	rm -f $(PPU_TARGET)
+	rm -f $(OBJ)
+
+.PHONY: clean

README.md

@@ -1,32 +1,57 @@
-# SSNES
+# RetroArch
 
-SSNES is a simple frontend for the libsnes library.
+RetroArch (formerly known as SSNES) is a simple frontend for the libretro API. An API that attempts to generalize
+a retro gaming system, such as SNES, NES, GameBoy, Arcade machines, etc.
+Emulator/game cores are instantiated as loadable plugins.
 
-# libsnes
+# libretro
 
-libsnes is the emulator core of [bSNES](http://www.byuu.org), the most accurate SNES emulator to date, in library form. The libsnes API has been implemented by SNES9x as well, allowing multiple different cores to be used for an emulator that supports libsnes.
-This enables the possibility of custom front-ends for the emulator.
+libretro is an API that exposes the core of a retro gaming system.
+A frontend for libretro handles video output, audio output and input.
+A libretro core written in portable C or C++ can run seamlessly on many platforms.
+
+[libretro API header](https://github.com/Themaister/RetroArch/blob/master/libretro.h)
+
+# Binaries
+
+Latest Windows binaries are currently hosted on my [homepage](http://themaister.net/retroarch.html).
+
+# Related projects
+
+   - GUI frontend for PC: [RetroArch-Phoenix](https://github.com/Themaister/RetroArch-Phoenix)
+   - Cg/HLSL shaders: [common-shaders](https://github.com/twinaphex/common-shaders)
+   - More Cg shaders: [Emulator-Shader-Pack](https://github.com/Themaister/Emulator-Shader-Pack)
+   - Helper scripts to build libretro implementations: [libretro-super](https://github.com/libretro/libretro-super)
 
 # Philosophy
 
-SSNES attempts to be very small and lean, while still having all the useful core features expected from an emulator. 
-It is used through command-line.
+RetroArch attempts to be very small and lean,
+while still having all the useful core features expected from an emulator. 
+It is used through command-line. It is also designed to be portable.
 
-# Dependencies
+# Platforms
 
-SSNES requires these libraries to build:
+RetroArch has been ported to the following platforms outside PC:
+
+   - PlayStation3
+   - Xbox 360 (Libxenon/XeXDK)
+   - Wii (Libogc)
+   - Raspberry Pi
+
+# Dependencies (PC)
+
+RetroArch requires these libraries to build:
 
-   - [libsnes](http://byuu.org/bsnes/)
    - SDL
-   - libsamplerate
 
-SSNES can utilize these libraries if enabled:
+RetroArch can utilize these libraries if enabled:
 
    - nvidia-cg-toolkit
-   - libxml2 (bSNES XML shaders)
+   - libxml2 (GLSL XML shaders)
    - libfreetype2 (TTF font rendering on screen)
+   - libsamplerate
 
-SSNES needs one of these audio driver libraries:
+RetroArch needs at least one of these audio driver libraries:
 
    - ALSA
    - OSS
@@ -35,61 +60,96 @@ SSNES needs one of these audio driver libraries:
    - OpenAL
    - JACK
    - SDL
+   - XAudio2 (Win32)
+   - PulseAudio
 
-# Building libsnes
+To run properly, RetroArch requires a libretro implementation present, however, as it's typically loaded
+dynamically, it's not required at build time.
 
-   - Download bSNES source (link over).
-   - Add -fPIC to flags in Makefile.
-   - <tt>$ make library profile=performance</tt> (accuracy, compatibility are the other profiles. compatibility is a great choice for decent PCs. :D)
-   - <tt># make prefix=/usr library-install</tt>
-   - <tt># cp snes/libsnes/libsnes.hpp /usr/include/</tt>
-   - ?!?!
-   - Profit!
+# Dependencies (Console ports)
+
+Console ports have their own dependencies, but generally do not require
+anything other than what the respective SDKs provide.
 
 # Configuring
 
 The default configuration is defined in config.def.h. 
-These can later be tweaked by using the ssnes config file. 
-A sample configuration file is installed to /etc/ssnes.cfg. 
+These can later be tweaked by using a config file. 
+A sample configuration file is installed to /etc/retroarch.cfg. 
 This is the system-wide config file. 
-Each user should create a config file in $XDG\_CONFIG\_HOME/ssnes/ssnes.cfg.
+Each user should create a config file in $XDG\_CONFIG\_HOME/retroarch/retroarch.cfg.
 The users only need to configure a certain option if the desired value deviates from the value defined in config.def.h.
 
-To configure joypads, start up <tt>jstest /dev/input/js0</tt> to determine which joypad buttons (and axis) to use. It is also possible to use the <tt>ssnes-joyconfig</tt> tool as well for simple configuration.
+To configure joypads, use the <tt>retroarch-joyconfig</tt> tool.
+It is also possible to configure joypads using the RetroArch-Phoenix GUI frontend.
 
 # Compiling and installing
 
-<b>Linux/Unix</b><br/>
-As most packages, SSNES is built using the standard <tt>./configure && make && make install</tt>
-Do note that the build system is not autotools based, but resembles it.
+<b>PC</b><br/>
+Instructions for compiling on PC can be found in the [wiki](https://github.com/Themaister/RetroArch/wiki).
 
-Notable options for ./configure: 
---with-libsnes=: Normally libsnes is located with -lsnes, however, this can be overridden.
---enable-dynamic: Do not link to libsnes at compile time, but load libsnes dynamically at runtime. libsnes\_path in config file defines which library to load. Useful for development.
+<b>PlayStation3</b><br/>
 
-Do note that these two options are mutually exclusive.
+RetroArch PS3 needs to be compiled in the following order:
 
-<b>Win32</b><br/>
-It is possible with MinGW to compile for Windows in either msys or Linux/Unix based systems. Do note that Windows build uses a static Makefile since configuration scripts create more harm than good on this platform. Libraries, headers, etc, needed to compile and run SSNES can be fetched with a Makefile target.
+1) Compile RetroArch Salamander
 
-In Linux/Unix:<br/>
-<tt>make -f Makefile.win32 libs</tt></br>
-<tt>make -f Makefile.win32 CC=i486-mingw32-gcc CXX=i486-mingw32-g++</tt></br>
+<tt>make -f Makefile.ps3.salamander</tt>
 
-In MSYS:
-<tt>mingw32-make -f Makefile.win32 libs</tt>. # You will need to have wget in your patch for this command! MSYS should provide this.</br>
-<tt>mingw32-make -f Makefile.win32</tt>
+2) Compile the RGL video driver
 
+<tt>make -f Makefile.ps3.rgl</tt>
 
+3) Compile RetroArch as a library
 
-# Filters, bSNES XML shaders and Cg shader support
+<tt>make -f Makefile.ps3.retroarch</tt>
 
-This is not strictly not necessary for an emulator, but it can be enabled if desired. 
-For best performance, Cg shaders or bSNES XML shaders are recommended as they do not eat up valuable CPU time (assuming your GPU can handle the shaders). 
-Cg shaders and XML shaders (GLSL) are compiled at run-time.
-All shaders share a common interface to pass some essential arguments such as texture size and viewport size. (Common for pixel art scalers)
-Some Cg shaders are included in hqflt/cg/ and could be used as an example.
-bSNES XML shaders can be found on various places on the net. Best place to start looking are the bSNES forums.
+4) Finally, compile RetroArch packed together with the GUI:
 
-The Cg shaders closely resemble the GLSL shaders found in bSNES shader pack, so porting them is trivial if desired.
+<tt>make -f Makefile.ps3</tt>
+
+<b>PlayStation3 - Creating a PKG installable file</b><br />
+
+You can add 'pkg' as a parameter in order to make a PKG file - for example:
+
+<tt>make -f Makefile.ps3 pkg</tt>
+
+This creates an NPDRM package. This can be installed on debug PS3s.
+
+To make a non-NPDRM package that can be installed on a jailbroken/CFW PS3 (such as PSGroove or PS3 CFWs and other 3.55 CFW derivatives), do:
+
+<tt>make -f Makefile.ps3 pkg-signed</tt>
+
+If you're using Kmeaw 3.55 firmware, the package needs to be signed:
+
+<tt>make -f Makefile.ps3 pkg-signed-cfw</tt>
+
+NOTE: A pre-existing libretro library needs to be present in the root directory in order to link RetroArch PS3. This file needs to be called <em><b>'libretro_ps3.a'</b></em>.
+
+<b> Xbox 360 (XeXDK)</b><br />
+
+You will need Microsoft Visual Studio 2010 installed (or higher) in order to compile RetroArch 360.
+
+The solution file can be found at the following location:
+
+<tt>msvc-360/RetroArch-360.sln</tt>
+
+NOTE: A pre-existing libretro library needs to be present in the 'msvc-360/RetroArch-360/Release' directory in order to link RetroArch 360. This file needs to be
+called <em><b>'libretro_xdk360.lib'</b></em>.
+
+<b> Xbox 360 (Libxenon)</b><br />
+
+You will need to have the libxenon libraries and a working Devkit Xenon toolchain installed in order to compile RetroArch 360 Libxenon.
+
+<tt>make -f Makefile.xenon</tt>
+
+NOTE: A pre-existing libretro library needs to be present in the root directory in order to link RetroArch 360 Libxenon. This file needs to be called <em><b>'libretro_xenon360.a'</b></em>.
+
+<b> Wii</b><br >
+
+You will need to have the libogc libraries and a working Devkit PPC toolchain installed in order to compile RetroArch Wii.
+
+<tt>make -f Makefile.wii</tt>
+
+NOTE: A pre-existing libretro library needs to be present in the root directory in order to link RetroArch Wii. This file needs to be called <em><b>'libretro_wii.a'</b></em>.
 

android/native/.classpath

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
+	<classpathentry kind="output" path="bin/classes"/>
+</classpath>

android/native/.project

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>android.app.NativeActivity</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

android/native/AndroidManifest.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- BEGIN_INCLUDE(manifest) -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+        package="com.retroarch.retroarch"
+        android:versionCode="1"
+        android:versionName="1.0">
+
+    <!-- This is the platform API where NativeActivity was introduced. -->
+    <uses-sdk android:minSdkVersion="9" />
+
+    <!-- This .apk has no Java code itself, so set hasCode to false. -->
+    <application android:label="@string/app_name" android:hasCode="false">
+
+        <!-- Our activity is the built-in NativeActivity framework class.
+             This will take care of integrating with our NDK code. -->
+        <activity android:name="android.app.NativeActivity"
+                android:label="@string/app_name"
+                android:configChanges="orientation|keyboardHidden">
+            <!-- Tell NativeActivity the name of or .so -->
+            <meta-data android:name="android.app.lib_name"
+                    android:value="retroarch" />
+            <meta-data android:name="android.app.func_name"
+                    android:value="ANativeActivity_onCreate" />
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest> 
+<!-- END_INCLUDE(manifest) -->

android/native/jni/Android.mk

@@ -0,0 +1,62 @@
+RARCH_VERSION		= "0.9.8"
+LOCAL_PATH := $(call my-dir)
+PERF_TEST := 0
+HAVE_NEON := 1
+HAVE_SINC := 1
+HAVE_LOGGER := 1
+
+include $(CLEAR_VARS)
+
+ifeq ($(TARGET_ARCH),arm)
+LOCAL_CFLAGS += -DANDROID_ARM -marm
+LOCAL_ARM_MODE := arm
+endif
+
+ifeq ($(TARGET_ARCH),x86)
+LOCAL_CFLAGS += -DANDROID_X86 -DHAVE_SSSE3
+endif
+
+ifeq ($(TARGET_ARCH_ABI),armeabi-v7a)
+
+ifeq ($(HAVE_NEON),1)
+LOCAL_CFLAGS += -DHAVE_NEON
+LOCAL_SRC_FILES += ../../../audio/utils_neon.S.neon
+endif
+
+ifeq ($(HAVE_SINC),1)
+ifeq ($(HAVE_NEON),1)
+LOCAL_SRC_FILES += ../../../audio/sinc_neon.S.neon
+endif
+LOCAL_CFLAGS += -DHAVE_SINC
+endif
+
+LOCAL_CFLAGS += -DANDROID_ARM_V7
+endif
+
+
+ifeq ($(TARGET_ARCH),mips)
+LOCAL_CFLAGS += -DANDROID_MIPS -D__mips__ -D__MIPSEL__
+endif
+
+LOCAL_MODULE    := retroarch-activity
+
+RARCH_PATH  := ../../..
+LOCAL_SRC_FILES  +=	$(RARCH_PATH)/console/griffin/griffin.c
+
+ifeq ($(HAVE_LOGGER), 1)
+LOCAL_CFLAGS += -DHAVE_LOGGER
+LOGGER_LDLIBS := -llog
+endif
+
+ifeq ($(PERF_TEST), 1)
+LOCAL_CFLAGS += -DPERF_TEST
+endif
+
+LOCAL_CFLAGS += -Wall -Wno-unused-function -O3 -fno-stack-protector -funroll-loops -DNDEBUG -DHAVE_GRIFFIN -DANDROID -DHAVE_DYNAMIC -DHAVE_OPENGL -DHAVE_FBO -DHAVE_OVERLAY -DHAVE_OPENGLES -DHAVE_VID_CONTEXT -DHAVE_OPENGLES2 -DGLSL_DEBUG -DHAVE_GLSL -DWANT_RZLIB -DHAVE_ZLIB -DINLINE=inline -DLSB_FIRST -DHAVE_THREAD -D__LIBRETRO__ -DRARCH_PERFORMANCE_MODE -DPACKAGE_VERSION=\"$(RARCH_VERSION)\" -std=gnu99 -I../../../deps/rzlib
+
+LOCAL_LDLIBS	:= -L$(SYSROOT)/usr/lib -landroid -lEGL -lGLESv2 $(LOGGER_LDLIBS) -ldl
+
+LOCAL_CFLAGS += -DHAVE_SL
+LOCAL_LDLIBS += -lOpenSLES
+
+include $(BUILD_SHARED_LIBRARY)

android/native/jni/Application.mk

@@ -0,0 +1,2 @@
+APP_PLATFORM := android-9
+APP_ABI := all

android/native/jni/cpufeatures.c

@@ -0,0 +1,547 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/* ChangeLog for this library:
+ *
+ * NDK r7c: Fix CPU count computation. The old method only reported the
+ *           number of _active_ CPUs when the library was initialized,
+ *           which could be less than the real total.
+ *
+ * NDK r5: Handle buggy kernels which report a CPU Architecture number of 7
+ *         for an ARMv6 CPU (see below).
+ *
+ *         Handle kernels that only report 'neon', and not 'vfpv3'
+ *         (VFPv3 is mandated by the ARM architecture is Neon is implemented)
+ *
+ *         Handle kernels that only report 'vfpv3d16', and not 'vfpv3'
+ *
+ *         Fix x86 compilation. Report ANDROID_CPU_FAMILY_X86 in
+ *         android_getCpuFamily().
+ *
+ * NDK r4: Initial release
+ */
+#include <sys/system_properties.h>
+#ifdef __arm__
+#include <machine/cpu-features.h>
+#endif
+#include <pthread.h>
+#include "cpufeatures.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <errno.h>
+
+static  pthread_once_t     g_once;
+static  AndroidCpuFamily   g_cpuFamily;
+static  uint64_t           g_cpuFeatures;
+static  int                g_cpuCount;
+
+#ifdef __arm__
+#  define DEFAULT_CPU_FAMILY  ANDROID_CPU_FAMILY_ARM
+#elif defined __i386__
+#  define DEFAULT_CPU_FAMILY  ANDROID_CPU_FAMILY_X86
+#else
+#  define DEFAULT_CPU_FAMILY  ANDROID_CPU_FAMILY_UNKNOWN
+#endif
+
+#define  D(...) \
+    do { \
+    } while (0)
+
+#ifdef __i386__
+static __inline__ void cpu_x86_cpuid(int func, int values[4])
+{
+    int a, b, c, d;
+    /* We need to preserve ebx since we're compiling PIC code */
+    /* this means we can't use "=b" for the second output register */
+    __asm__ __volatile__ ( \
+      "push %%ebx\n"
+      "cpuid\n" \
+      "mov %1, %%ebx\n"
+      "pop %%ebx\n"
+      : "=a" (a), "=r" (b), "=c" (c), "=d" (d) \
+      : "a" (func) \
+    );
+    values[0] = a;
+    values[1] = b;
+    values[2] = c;
+    values[3] = d;
+}
+#endif
+
+/* Read the content of /proc/cpuinfo into a user-provided buffer.
+ * Return the length of the data, or -1 on error. Does *not*
+ * zero-terminate the content. Will not read more
+ * than 'buffsize' bytes.
+ */
+static int
+cpu_read_file(const char*  pathname, char*  buffer, size_t  buffsize)
+{
+    int  fd, len;
+
+    fd = open(pathname, O_RDONLY);
+    if (fd < 0)
+        return -1;
+
+    do {
+        len = read(fd, buffer, buffsize);
+    } while (len < 0 && errno == EINTR);
+
+    close(fd);
+
+    return len;
+}
+
+/* Extract the content of a the first occurence of a given field in
+ * the content of /proc/cpuinfo and return it as a heap-allocated
+ * string that must be freed by the caller.
+ *
+ * Return NULL if not found
+ */
+static char*
+extract_cpuinfo_field(char* buffer, int buflen, const char* field)
+{
+    int  fieldlen = strlen(field);
+    char* bufend = buffer + buflen;
+    char* result = NULL;
+    int len;
+    const char *p, *q;
+
+    /* Look for first field occurence, and ensures it starts the line.
+     */
+    p = buffer;
+    bufend = buffer + buflen;
+    for (;;) {
+        p = memmem(p, bufend-p, field, fieldlen);
+        if (p == NULL)
+            goto EXIT;
+
+        if (p == buffer || p[-1] == '\n')
+            break;
+
+        p += fieldlen;
+    }
+
+    /* Skip to the first column followed by a space */
+    p += fieldlen;
+    p  = memchr(p, ':', bufend-p);
+    if (p == NULL || p[1] != ' ')
+        goto EXIT;
+
+    /* Find the end of the line */
+    p += 2;
+    q = memchr(p, '\n', bufend-p);
+    if (q == NULL)
+        q = bufend;
+
+    /* Copy the line into a heap-allocated buffer */
+    len = q-p;
+    result = malloc(len+1);
+    if (result == NULL)
+        goto EXIT;
+
+    memcpy(result, p, len);
+    result[len] = '\0';
+
+EXIT:
+    return result;
+}
+
+/* Like strlen(), but for constant string literals */
+#define STRLEN_CONST(x)  ((sizeof(x)-1)
+
+
+/* Checks that a space-separated list of items contains one given 'item'.
+ * Returns 1 if found, 0 otherwise.
+ */
+static int
+has_list_item(const char* list, const char* item)
+{
+    const char*  p = list;
+    int itemlen = strlen(item);
+
+    if (list == NULL)
+        return 0;
+
+    while (*p) {
+        const char*  q;
+
+        /* skip spaces */
+        while (*p == ' ' || *p == '\t')
+            p++;
+
+        /* find end of current list item */
+        q = p;
+        while (*q && *q != ' ' && *q != '\t')
+            q++;
+
+        if (itemlen == q-p && !memcmp(p, item, itemlen))
+            return 1;
+
+        /* skip to next item */
+        p = q;
+    }
+    return 0;
+}
+
+/* Parse an decimal integer starting from 'input', but not going further
+ * than 'limit'. Return the value into '*result'.
+ *
+ * NOTE: Does not skip over leading spaces, or deal with sign characters.
+ * NOTE: Ignores overflows.
+ *
+ * The function returns NULL in case of error (bad format), or the new
+ * position after the decimal number in case of success (which will always
+ * be <= 'limit').
+ */
+static const char*
+parse_decimal(const char* input, const char* limit, int* result)
+{
+    const char* p = input;
+    int val = 0;
+    while (p < limit) {
+        int d = (*p - '0');
+        if ((unsigned)d >= 10U)
+            break;
+        val = val*10 + d;
+        p++;
+    }
+    if (p == input)
+        return NULL;
+
+    *result = val;
+    return p;
+}
+
+/* This small data type is used to represent a CPU list / mask, as read
+ * from sysfs on Linux. See http://www.kernel.org/doc/Documentation/cputopology.txt
+ *
+ * For now, we don't expect more than 32 cores on mobile devices, so keep
+ * everything simple.
+ */
+typedef struct {
+    uint32_t mask;
+} CpuList;
+
+static __inline__ void
+cpulist_init(CpuList* list) {
+    list->mask = 0;
+}
+
+static __inline__ void
+cpulist_and(CpuList* list1, CpuList* list2) {
+    list1->mask &= list2->mask;
+}
+
+static __inline__ void
+cpulist_set(CpuList* list, int index) {
+    if ((unsigned)index < 32) {
+        list->mask |= (uint32_t)(1U << index);
+    }
+}
+
+static __inline__ int
+cpulist_count(CpuList* list) {
+    return __builtin_popcount(list->mask);
+}
+
+/* Parse a textual list of cpus and store the result inside a CpuList object.
+ * Input format is the following:
+ * - comma-separated list of items (no spaces)
+ * - each item is either a single decimal number (cpu index), or a range made
+ *   of two numbers separated by a single dash (-). Ranges are inclusive.
+ *
+ * Examples:   0
+ *             2,4-127,128-143
+ *             0-1
+ */
+static void
+cpulist_parse(CpuList* list, const char* line, int line_len)
+{
+    const char* p = line;
+    const char* end = p + line_len;
+    const char* q;
+
+    /* NOTE: the input line coming from sysfs typically contains a
+     * trailing newline, so take care of it in the code below
+     */
+    while (p < end && *p != '\n')
+    {
+        int val, start_value, end_value;
+
+        /* Find the end of current item, and put it into 'q' */
+        q = memchr(p, ',', end-p);
+        if (q == NULL) {
+            q = end;
+        }
+
+        /* Get first value */
+        p = parse_decimal(p, q, &start_value);
+        if (p == NULL)
+            goto BAD_FORMAT;
+
+        end_value = start_value;
+
+        /* If we're not at the end of the item, expect a dash and
+         * and integer; extract end value.
+         */
+        if (p < q && *p == '-') {
+            p = parse_decimal(p+1, q, &end_value);
+            if (p == NULL)
+                goto BAD_FORMAT;
+        }
+
+        /* Set bits CPU list bits */
+        for (val = start_value; val <= end_value; val++) {
+            cpulist_set(list, val);
+        }
+
+        /* Jump to next item */
+        p = q;
+        if (p < end)
+            p++;
+    }
+
+BAD_FORMAT:
+    ;
+}
+
+/* Read a CPU list from one sysfs file */
+static void
+cpulist_read_from(CpuList* list, const char* filename)
+{
+    char   file[64];
+    int    filelen;
+
+    cpulist_init(list);
+
+    filelen = cpu_read_file(filename, file, sizeof file);
+    if (filelen < 0) {
+        D("Could not read %s: %s\n", filename, strerror(errno));
+        return;
+    }
+
+    cpulist_parse(list, file, filelen);
+}
+
+/* Return the number of cpus present on a given device.
+ *
+ * To handle all weird kernel configurations, we need to compute the
+ * intersection of the 'present' and 'possible' CPU lists and count
+ * the result.
+ */
+static int
+get_cpu_count(void)
+{
+    CpuList cpus_present[1];
+    CpuList cpus_possible[1];
+
+    cpulist_read_from(cpus_present, "/sys/devices/system/cpu/present");
+    cpulist_read_from(cpus_possible, "/sys/devices/system/cpu/possible");
+
+    /* Compute the intersection of both sets to get the actual number of
+     * CPU cores that can be used on this device by the kernel.
+     */
+    cpulist_and(cpus_present, cpus_possible);
+
+    return cpulist_count(cpus_present);
+}
+
+static void
+android_cpuInit(void)
+{
+    char cpuinfo[4096];
+    int  cpuinfo_len;
+
+    g_cpuFamily   = DEFAULT_CPU_FAMILY;
+    g_cpuFeatures = 0;
+    g_cpuCount    = 1;
+
+    cpuinfo_len = cpu_read_file("/proc/cpuinfo", cpuinfo, sizeof cpuinfo);
+    D("cpuinfo_len is (%d):\n%.*s\n", cpuinfo_len,
+      cpuinfo_len >= 0 ? cpuinfo_len : 0, cpuinfo);
+
+    if (cpuinfo_len < 0)  /* should not happen */ {
+        return;
+    }
+
+    /* Count the CPU cores, the value may be 0 for single-core CPUs */
+    g_cpuCount = get_cpu_count();
+    if (g_cpuCount == 0) {
+        g_cpuCount = 1;
+    }
+
+    D("found cpuCount = %d\n", g_cpuCount);
+
+#ifdef __ARM_ARCH__
+    {
+        /* Extract architecture from the "CPU Architecture" field.
+         * The list is well-known, unlike the the output of
+         * the 'Processor' field which can vary greatly.
+         *
+         * See the definition of the 'proc_arch' array in
+         * $KERNEL/arch/arm/kernel/setup.c and the 'c_show' function in
+         * same file.
+         */
+        char* cpuArch = extract_cpuinfo_field(cpuinfo, cpuinfo_len, "CPU architecture");
+
+        if (cpuArch != NULL) {
+            char*  end;
+            long   archNumber;
+            int    hasARMv7 = 0;
+
+            D("found cpuArch = '%s'\n", cpuArch);
+
+            /* read the initial decimal number, ignore the rest */
+            archNumber = strtol(cpuArch, &end, 10);
+
+            /* Here we assume that ARMv8 will be upwards compatible with v7
+                * in the future. Unfortunately, there is no 'Features' field to
+                * indicate that Thumb-2 is supported.
+                */
+            if (end > cpuArch && archNumber >= 7) {
+                hasARMv7 = 1;
+            }
+
+            /* Unfortunately, it seems that certain ARMv6-based CPUs
+             * report an incorrect architecture number of 7!
+             *
+             * See http://code.google.com/p/android/issues/detail?id=10812
+             *
+             * We try to correct this by looking at the 'elf_format'
+             * field reported by the 'Processor' field, which is of the
+             * form of "(v7l)" for an ARMv7-based CPU, and "(v6l)" for
+             * an ARMv6-one.
+             */
+            if (hasARMv7) {
+                char* cpuProc = extract_cpuinfo_field(cpuinfo, cpuinfo_len,
+                                                      "Processor");
+                if (cpuProc != NULL) {
+                    D("found cpuProc = '%s'\n", cpuProc);
+                    if (has_list_item(cpuProc, "(v6l)")) {
+                        D("CPU processor and architecture mismatch!!\n");
+                        hasARMv7 = 0;
+                    }
+                    free(cpuProc);
+                }
+            }
+
+            if (hasARMv7) {
+                g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_ARMv7;
+            }
+
+            /* The LDREX / STREX instructions are available from ARMv6 */
+            if (archNumber >= 6) {
+                g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_LDREX_STREX;
+            }
+
+            free(cpuArch);
+        }
+
+        /* Extract the list of CPU features from 'Features' field */
+        char* cpuFeatures = extract_cpuinfo_field(cpuinfo, cpuinfo_len, "Features");
+
+        if (cpuFeatures != NULL) {
+
+            D("found cpuFeatures = '%s'\n", cpuFeatures);
+
+            if (has_list_item(cpuFeatures, "vfpv3"))
+                g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_VFPv3;
+
+            else if (has_list_item(cpuFeatures, "vfpv3d16"))
+                g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_VFPv3;
+
+            if (has_list_item(cpuFeatures, "neon")) {
+                /* Note: Certain kernels only report neon but not vfpv3
+                    *       in their features list. However, ARM mandates
+                    *       that if Neon is implemented, so must be VFPv3
+                    *       so always set the flag.
+                    */
+                g_cpuFeatures |= ANDROID_CPU_ARM_FEATURE_NEON |
+                                 ANDROID_CPU_ARM_FEATURE_VFPv3;
+            }
+            free(cpuFeatures);
+        }
+    }
+#endif /* __ARM_ARCH__ */
+
+#ifdef __i386__
+    g_cpuFamily = ANDROID_CPU_FAMILY_X86;
+
+    int regs[4];
+
+/* According to http://en.wikipedia.org/wiki/CPUID */
+#define VENDOR_INTEL_b  0x756e6547
+#define VENDOR_INTEL_c  0x6c65746e
+#define VENDOR_INTEL_d  0x49656e69
+
+    cpu_x86_cpuid(0, regs);
+    int vendorIsIntel = (regs[1] == VENDOR_INTEL_b &&
+                         regs[2] == VENDOR_INTEL_c &&
+                         regs[3] == VENDOR_INTEL_d);
+
+    cpu_x86_cpuid(1, regs);
+    if ((regs[2] & (1 << 9)) != 0) {
+        g_cpuFeatures |= ANDROID_CPU_X86_FEATURE_SSSE3;
+    }
+    if ((regs[2] & (1 << 23)) != 0) {
+        g_cpuFeatures |= ANDROID_CPU_X86_FEATURE_POPCNT;
+    }
+    if (vendorIsIntel && (regs[2] & (1 << 22)) != 0) {
+        g_cpuFeatures |= ANDROID_CPU_X86_FEATURE_MOVBE;
+    }
+#endif
+
+#ifdef _MIPS_ARCH
+    g_cpuFamily = ANDROID_CPU_FAMILY_MIPS;
+#endif /* _MIPS_ARCH */
+}
+
+
+AndroidCpuFamily
+android_getCpuFamily(void)
+{
+    pthread_once(&g_once, android_cpuInit);
+    return g_cpuFamily;
+}
+
+
+uint64_t
+android_getCpuFeatures(void)
+{
+    pthread_once(&g_once, android_cpuInit);
+    return g_cpuFeatures;
+}
+
+
+int
+android_getCpuCount(void)
+{
+    pthread_once(&g_once, android_cpuInit);
+    return g_cpuCount;
+}

android/native/jni/cpufeatures.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+#ifndef CPU_FEATURES_H
+#define CPU_FEATURES_H
+
+#include <sys/cdefs.h>
+#include <stdint.h>
+
+typedef enum {
+    ANDROID_CPU_FAMILY_UNKNOWN = 0,
+    ANDROID_CPU_FAMILY_ARM,
+    ANDROID_CPU_FAMILY_X86,
+    ANDROID_CPU_FAMILY_MIPS,
+
+    ANDROID_CPU_FAMILY_MAX  /* do not remove */
+
+} AndroidCpuFamily;
+
+/* Return family of the device's CPU */
+extern AndroidCpuFamily   android_getCpuFamily(void);
+
+enum {
+    ANDROID_CPU_ARM_FEATURE_ARMv7       = (1 << 0),
+    ANDROID_CPU_ARM_FEATURE_VFPv3       = (1 << 1),
+    ANDROID_CPU_ARM_FEATURE_NEON        = (1 << 2),
+    ANDROID_CPU_ARM_FEATURE_LDREX_STREX = (1 << 3),
+};
+
+enum {
+    ANDROID_CPU_X86_FEATURE_SSSE3  = (1 << 0),
+    ANDROID_CPU_X86_FEATURE_POPCNT = (1 << 1),
+    ANDROID_CPU_X86_FEATURE_MOVBE  = (1 << 2),
+};
+
+extern uint64_t    android_getCpuFeatures(void);
+
+/* Return the number of CPU cores detected on this device. */
+extern int         android_getCpuCount(void);
+
+#endif /* CPU_FEATURES_H */

android/native/jni/input_android.c

@@ -0,0 +1,285 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
+ *  Copyright (C) 2011-2013 - Daniel De Matteis
+ * 
+ *  RetroArch 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.
+ *
+ *  RetroArch 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 RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <android/keycodes.h>
+#include <unistd.h>
+#include "input_autodetect.h"
+#include "../../../frontend/frontend_android.h"
+#include "../../../input/input_common.h"
+#include "../../../performance.h"
+#include "../../../general.h"
+#include "../../../driver.h"
+
+#define MAX_TOUCH 16
+
+#define PRESSED_UP(x, y)   ((-0.80f > y) && (x >= -1.00f))
+#define PRESSED_DOWN(x, y) ((0.80f  < y) && (y <= 1.00f))
+#define PRESSED_LEFT(x, y) ((-0.80f > x) && (x >= -1.00f))
+#define PRESSED_RIGHT(x, y) ((0.80f  < x) && (x <= 1.00f))
+
+static unsigned pads_connected;
+static int state_device_ids[MAX_PADS];
+static uint64_t state[MAX_PADS];
+
+struct input_pointer
+{
+   int16_t x, y;
+   int16_t full_x, full_y;
+};
+
+static struct input_pointer pointer[MAX_TOUCH];
+static unsigned pointer_count;
+
+static void *android_input_init(void)
+{
+   pads_connected = 0;
+
+   for(unsigned player = 0; player < 4; player++)
+      for(unsigned i = 0; i < RARCH_FIRST_META_KEY; i++)
+      {
+         g_settings.input.binds[player][i].id = i;
+         g_settings.input.binds[player][i].joykey = 0;
+      }
+
+   for(int player = 0; player < 4; player++)
+   {
+      g_settings.input.binds[player][RETRO_DEVICE_ID_JOYPAD_B].joykey = (1ULL << RETRO_DEVICE_ID_JOYPAD_B);
+      g_settings.input.binds[player][RETRO_DEVICE_ID_JOYPAD_Y].joykey = (1ULL << RETRO_DEVICE_ID_JOYPAD_Y);
+      g_settings.input.binds[player][RETRO_DEVICE_ID_JOYPAD_SELECT].joykey = (1ULL << RETRO_DEVICE_ID_JOYPAD_SELECT);
+      g_settings.input.binds[player][RETRO_DEVICE_ID_JOYPAD_START].joykey = (1ULL << RETRO_DEVICE_ID_JOYPAD_START);
+      g_settings.input.binds[player][RETRO_DEVICE_ID_JOYPAD_UP].joykey = (1ULL << RETRO_DEVICE_ID_JOYPAD_UP);
+      g_settings.input.binds[player][RETRO_DEVICE_ID_JOYPAD_DOWN].joykey = (1ULL << RETRO_DEVICE_ID_JOYPAD_DOWN);
+      g_settings.input.binds[player][RETRO_DEVICE_ID_JOYPAD_LEFT].joykey = (1ULL << RETRO_DEVICE_ID_JOYPAD_LEFT);
+      g_settings.input.binds[player][RETRO_DEVICE_ID_JOYPAD_RIGHT].joykey = (1ULL << RETRO_DEVICE_ID_JOYPAD_RIGHT);
+      g_settings.input.binds[player][RETRO_DEVICE_ID_JOYPAD_A].joykey = (1ULL << RETRO_DEVICE_ID_JOYPAD_A);
+      g_settings.input.binds[player][RETRO_DEVICE_ID_JOYPAD_X].joykey = (1ULL << RETRO_DEVICE_ID_JOYPAD_X);
+      g_settings.input.binds[player][RETRO_DEVICE_ID_JOYPAD_L].joykey = (1ULL << RETRO_DEVICE_ID_JOYPAD_L);
+      g_settings.input.binds[player][RETRO_DEVICE_ID_JOYPAD_R].joykey = (1ULL << RETRO_DEVICE_ID_JOYPAD_R);
+      g_settings.input.binds[player][RETRO_DEVICE_ID_JOYPAD_L2].joykey = (1ULL << RETRO_DEVICE_ID_JOYPAD_L2);
+      g_settings.input.binds[player][RETRO_DEVICE_ID_JOYPAD_R2].joykey = (1ULL << RETRO_DEVICE_ID_JOYPAD_R2);
+      g_settings.input.binds[player][RETRO_DEVICE_ID_JOYPAD_L3].joykey = (1ULL << RETRO_DEVICE_ID_JOYPAD_L3);
+      g_settings.input.binds[player][RETRO_DEVICE_ID_JOYPAD_R3].joykey = (1ULL << RETRO_DEVICE_ID_JOYPAD_R3);
+   }
+
+   input_autodetect_init();
+   return (void*)-1;
+}
+
+static void android_input_poll(void *data)
+{
+   (void)data;
+
+   RARCH_PERFORMANCE_INIT(input_poll);
+   RARCH_PERFORMANCE_START(input_poll);
+
+   bool debug_enable = g_settings.input.debug_enable;
+   struct android_app* android_app = (struct android_app*)g_android;
+   uint64_t *lifecycle_state = &g_extern.lifecycle_state;
+
+   *lifecycle_state &= ~((1ULL << RARCH_RESET) | (1ULL << RARCH_REWIND) | (1ULL << RARCH_FAST_FORWARD_KEY) | (1ULL << RARCH_FAST_FORWARD_HOLD_KEY) | (1ULL << RARCH_MUTE) | (1ULL << RARCH_SAVE_STATE_KEY) | (1ULL << RARCH_LOAD_STATE_KEY) | (1ULL << RARCH_STATE_SLOT_PLUS) | (1ULL << RARCH_STATE_SLOT_MINUS));
+
+   // Read all pending events.
+   while (AInputQueue_hasEvents(android_app->inputQueue) > 0)
+   {
+      AInputEvent* event = NULL;
+      if (AInputQueue_getEvent(android_app->inputQueue, &event) < 0)
+         break;
+
+      int32_t handled = 1;
+      int action = 0;
+      char msg[128];
+      msg[0] = 0;
+
+      int source = AInputEvent_getSource(event);
+      int id = AInputEvent_getDeviceId(event);
+      int keycode = AKeyEvent_getKeyCode(event);
+
+      int type_event = AInputEvent_getType(event);
+      int state_id = -1;
+
+      for (unsigned i = 0; i < pads_connected; i++)
+         if (state_device_ids[i] == id)
+            state_id = i;
+
+      if (state_id < 0)
+      {
+         state_id = pads_connected;
+         state_device_ids[pads_connected++] = id;
+
+         input_autodetect_setup(android_app, msg, sizeof(msg), state_id, id, source);
+      }
+
+      if (keycode == AKEYCODE_BACK && (source & (AINPUT_SOURCE_KEYBOARD)))
+      {
+         *lifecycle_state |= (1ULL << RARCH_QUIT_KEY);
+         AInputQueue_finishEvent(android_app->inputQueue, event, handled);
+         break;
+      }
+      else if(type_event == AINPUT_EVENT_TYPE_MOTION && (g_settings.input.dpad_emulation[state_id] != DPAD_EMULATION_NONE))
+      {
+         float x = 0.0f;
+         float y = 0.0f;
+         action = AMotionEvent_getAction(event);
+         size_t motion_pointer = action >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
+         action &= AMOTION_EVENT_ACTION_MASK;
+
+         if(source & ~(AINPUT_SOURCE_TOUCHSCREEN | AINPUT_SOURCE_MOUSE))
+         {
+            uint64_t *state_cur = &state[state_id];
+            x = AMotionEvent_getX(event, motion_pointer);
+            y = AMotionEvent_getY(event, motion_pointer);
+            *state_cur &= ~((1ULL << RETRO_DEVICE_ID_JOYPAD_LEFT) | (1ULL << RETRO_DEVICE_ID_JOYPAD_RIGHT) |
+                  (1ULL << RETRO_DEVICE_ID_JOYPAD_UP) | (1ULL << RETRO_DEVICE_ID_JOYPAD_DOWN));
+            *state_cur |= PRESSED_LEFT(x, y)  ? (1ULL << RETRO_DEVICE_ID_JOYPAD_LEFT)  : 0;
+            *state_cur |= PRESSED_RIGHT(x, y) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_RIGHT) : 0;
+            *state_cur |= PRESSED_UP(x, y)    ? (1ULL << RETRO_DEVICE_ID_JOYPAD_UP)    : 0;
+            *state_cur |= PRESSED_DOWN(x, y)  ? (1ULL << RETRO_DEVICE_ID_JOYPAD_DOWN)  : 0;
+         }
+         else
+         {
+            bool keyup = (action == AMOTION_EVENT_ACTION_UP ||
+                  action == AMOTION_EVENT_ACTION_CANCEL || action == AMOTION_EVENT_ACTION_POINTER_UP) ||
+               (source == AINPUT_SOURCE_MOUSE && action != AMOTION_EVENT_ACTION_DOWN);
+
+            if (motion_pointer < MAX_TOUCH)
+            {
+               if (!keyup)
+               {
+                  x = AMotionEvent_getX(event, motion_pointer);
+                  y = AMotionEvent_getY(event, motion_pointer);
+
+                  input_translate_coord_viewport(x, y,
+                        &pointer[motion_pointer].x, &pointer[motion_pointer].y,
+                        &pointer[motion_pointer].full_x, &pointer[motion_pointer].full_y);
+
+                  pointer_count = max(pointer_count, motion_pointer + 1);
+               }
+               else
+               {
+                  memmove(pointer + motion_pointer, pointer + motion_pointer + 1, (MAX_TOUCH - motion_pointer - 1) * sizeof(struct input_pointer));
+                  if (pointer_count > 0)
+                     pointer_count--;
+               }
+            }
+            else
+               RARCH_WARN("Got motion pointer out of range (index: %u).\n", motion_pointer);
+         }
+
+         if (debug_enable)
+            snprintf(msg, sizeof(msg), "Pad %d : x = %.2f, y = %.2f, src %d.\n", state_id, x, y, source);
+      }
+      else if (type_event == AINPUT_EVENT_TYPE_KEY)
+      {
+         if (debug_enable)
+            snprintf(msg, sizeof(msg), "Pad %d : %d, ac = %d, src = %d.\n", state_id, keycode, action, source);
+
+         /* Hack - we have to decrease the unpacked value by 1
+          * because we 'added' 1 to each entry in the LUT -
+          * RETRO_DEVICE_ID_JOYPAD_B is 0
+          */
+         uint8_t unpacked = (keycode_lut[keycode] >> ((state_id+1) << 3)) - 1;
+         uint64_t input_state = (1ULL << unpacked);
+         int action  = AKeyEvent_getAction(event);
+         uint64_t *key = NULL;
+
+         if(input_state < (1ULL << RARCH_FIRST_META_KEY))
+            key = &state[state_id];
+         else if(input_state)
+            key = &g_extern.lifecycle_state;
+
+         if(key != NULL)
+         {
+            if (action == AKEY_EVENT_ACTION_UP)
+               *key &= ~(input_state);
+            else if (action == AKEY_EVENT_ACTION_DOWN)
+               *key |= input_state;
+         }
+
+         if(volume_enable && (keycode == AKEYCODE_VOLUME_UP || keycode == AKEYCODE_VOLUME_DOWN))
+            handled = 0;
+      }
+
+      if (msg[0] != 0)
+         msg_queue_push(g_extern.msg_queue, msg, 0, 30);
+
+      AInputQueue_finishEvent(android_app->inputQueue, event, handled);
+   }
+
+#if 0
+   {
+      char msg[64];
+      snprintf(msg, sizeof(msg), "Pointers: %u", pointer_count);
+      msg_queue_clear(g_extern.msg_queue);
+      msg_queue_push(g_extern.msg_queue, msg, 0, 30);
+   }
+#endif
+
+   RARCH_PERFORMANCE_STOP(input_poll);
+}
+
+static int16_t android_input_state(void *data, const struct retro_keybind **binds, unsigned port, unsigned device, unsigned index, unsigned id)
+{
+   switch (device)
+   {
+      case RETRO_DEVICE_JOYPAD:
+         return ((state[port] & binds[port][id].joykey) && (port < pads_connected));
+      case RETRO_DEVICE_POINTER:
+         switch(id)
+         {
+            case RETRO_DEVICE_ID_POINTER_X:
+               return pointer[index].x;
+            case RETRO_DEVICE_ID_POINTER_Y:
+               return pointer[index].y;
+            case RETRO_DEVICE_ID_POINTER_PRESSED:
+               return (index < pointer_count) && (pointer[index].x != -0x8000) && (pointer[index].y != -0x8000);
+            default:
+               return 0;
+         }
+      case RARCH_DEVICE_POINTER_SCREEN:
+         switch(id)
+         {
+            case RETRO_DEVICE_ID_POINTER_X:
+               return pointer[index].full_x;
+            case RETRO_DEVICE_ID_POINTER_Y:
+               return pointer[index].full_y;
+            case RETRO_DEVICE_ID_POINTER_PRESSED:
+               return (index < pointer_count) && (pointer[index].full_x != -0x8000) && (pointer[index].full_y != -0x8000);
+            default:
+               return 0;
+         }
+      default:
+         return 0;
+   }
+}
+
+static bool android_input_key_pressed(void *data, int key)
+{
+   return ((g_extern.lifecycle_state | driver.overlay_state) & (1ULL << key));
+}
+
+static void android_input_free_input(void *data)
+{
+   (void)data;
+}
+
+const input_driver_t input_android = {
+   android_input_init,
+   android_input_poll,
+   android_input_state,
+   android_input_key_pressed,
+   android_input_free_input,
+   "android_input",
+};

android/native/jni/input_autodetect.c

@@ -0,0 +1,485 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
+ *  Copyright (C) 2011-2013 - Daniel De Matteis
+ * 
+ *  RetroArch 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.
+ *
+ *  RetroArch 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 RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "../../../frontend/frontend_android.h"
+#include "jni_macros.h"
+#include "input_autodetect.h"
+
+uint64_t keycode_lut[LAST_KEYCODE];
+
+bool volume_enable;
+
+static void input_autodetect_get_device_name(void *data, char *buf, size_t size, int id)
+{
+   struct android_app *android_app = (struct android_app*)data;
+   buf[0] = '\0';
+
+   JavaVM *vm = android_app->activity->vm;
+   JNIEnv *env = NULL;
+   (*vm)->AttachCurrentThread(vm, &env, 0);
+
+   jclass input_device_class = NULL;
+   FIND_CLASS(env, input_device_class, "android/view/InputDevice");
+   if (!input_device_class)
+      goto end;
+
+   jmethodID method = NULL;
+   GET_STATIC_METHOD_ID(env, method, input_device_class, "getDevice", "(I)Landroid/view/InputDevice;");
+   if (!method)
+      goto end;
+
+   jobject device = NULL;
+   CALL_OBJ_STATIC_METHOD_PARAM(env, device, input_device_class, method, (jint)id);
+   if (!device)
+   {
+      RARCH_ERR("Failed to find device for ID: %d\n", id);
+      goto end;
+   }
+
+   jmethodID getName = NULL;
+   GET_METHOD_ID(env, getName, input_device_class, "getName", "()Ljava/lang/String;");
+   if (!getName)
+      goto end;
+
+   jobject name = NULL;
+   CALL_OBJ_METHOD(env, name, device, getName);
+   if (!name)
+   {
+      RARCH_ERR("Failed to find name for device ID: %d\n", id);
+      goto end;
+   }
+
+   const char *str = (*env)->GetStringUTFChars(env, name, 0);
+   if (str)
+      strlcpy(buf, str, size);
+   (*env)->ReleaseStringUTFChars(env, name, str);
+
+end:
+   (*vm)->DetachCurrentThread(vm);
+}
+
+void input_autodetect_init (void)
+{
+   for(int j = 0; j < LAST_KEYCODE; j++)
+      keycode_lut[j] = 0;
+
+   volume_enable = true;
+}
+
+void input_autodetect_setup (void *data, char *msg, size_t sizeof_msg, unsigned port, unsigned id, int source)
+{
+   struct android_app *android_app = (struct android_app*)data;
+   // Hack - we have to add '1' to the bit mask here because
+   // RETRO_DEVICE_ID_JOYPAD_B is 0
+ 
+   char name_buf[256];
+   name_buf[0] = 0;
+
+   if (port > MAX_PADS)
+   {
+      snprintf(msg, sizeof_msg, "Max number of pads reached.\n");
+      return;
+   }
+
+   /* eight 8-bit values are packed into one uint64_t
+    * one for each of the 8 pads */
+   uint8_t shift = 8 + (port * 8);
+
+   g_settings.input.dpad_emulation[port] = DPAD_EMULATION_LSTICK;
+
+   char *current_ime = android_app->current_ime;
+
+   if (g_settings.input.autodetect_enable)
+   {
+      input_autodetect_get_device_name(android_app, name_buf, sizeof(name_buf), id);
+
+      if (strstr(name_buf, "Logitech"))
+      {
+         if (strstr(name_buf, "RumblePad 2"))
+         {
+            snprintf(msg, sizeof_msg, "RetroPad #%d is: RumblePad 2.\n", port);
+            keycode_lut[AKEYCODE_BUTTON_2]  |=  ((RETRO_DEVICE_ID_JOYPAD_B+1)      << shift);
+            keycode_lut[AKEYCODE_BUTTON_1]  |=  ((RETRO_DEVICE_ID_JOYPAD_Y+1)      << shift);
+            keycode_lut[AKEYCODE_BUTTON_9]  |=  ((RETRO_DEVICE_ID_JOYPAD_SELECT+1) << shift);
+            keycode_lut[AKEYCODE_BUTTON_10] |= ((RETRO_DEVICE_ID_JOYPAD_START+1)   << shift);
+            keycode_lut[AKEYCODE_BUTTON_3]  |=  ((RETRO_DEVICE_ID_JOYPAD_A+1)      << shift);
+            keycode_lut[AKEYCODE_BUTTON_4]  |=  ((RETRO_DEVICE_ID_JOYPAD_X+1)      << shift);
+            keycode_lut[AKEYCODE_BUTTON_5]  |=  ((RETRO_DEVICE_ID_JOYPAD_L+1)      << shift);
+            keycode_lut[AKEYCODE_BUTTON_6]  |=  ((RETRO_DEVICE_ID_JOYPAD_R+1)      << shift);
+            keycode_lut[AKEYCODE_BUTTON_7]  |=  ((RETRO_DEVICE_ID_JOYPAD_L2+1)     << shift);
+            keycode_lut[AKEYCODE_BUTTON_8]  |=  ((RETRO_DEVICE_ID_JOYPAD_R2+1)     << shift);
+            keycode_lut[AKEYCODE_BUTTON_11] |= ((RETRO_DEVICE_ID_JOYPAD_L3+1)      << shift);
+            keycode_lut[AKEYCODE_BUTTON_12] |= ((RETRO_DEVICE_ID_JOYPAD_R3+1)      << shift);
+         }
+      }
+      else if (strstr(name_buf, "HuiJia  USB GamePad"))
+      {
+         snprintf(msg, sizeof_msg, "RetroPad #%d is: HuiJia USB Gamepad.\n", port);
+         keycode_lut[AKEYCODE_BUTTON_3]  |= ((RETRO_DEVICE_ID_JOYPAD_B+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_4]  |= ((RETRO_DEVICE_ID_JOYPAD_Y+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_9] |= ((RETRO_DEVICE_ID_JOYPAD_SELECT+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_10] |= ((RETRO_DEVICE_ID_JOYPAD_START+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_2]  |= ((RETRO_DEVICE_ID_JOYPAD_A+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_1]  |= ((RETRO_DEVICE_ID_JOYPAD_X+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_7] |= ((RETRO_DEVICE_ID_JOYPAD_L+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_8] |= ((RETRO_DEVICE_ID_JOYPAD_R+1) << shift);
+      }
+      else if (strstr(name_buf, "Microsoft"))
+      {
+         if (strstr(name_buf, "Dual Strike"))
+         {
+            snprintf(msg, sizeof_msg, "RetroPad #%d is: Sidewinder Dual Strike.\n", port);
+            keycode_lut[AKEYCODE_BUTTON_4] |= ((RETRO_DEVICE_ID_JOYPAD_B+1) << shift);
+            keycode_lut[AKEYCODE_BUTTON_2] |= ((RETRO_DEVICE_ID_JOYPAD_Y+1) << shift);
+            keycode_lut[AKEYCODE_BUTTON_6] |= ((RETRO_DEVICE_ID_JOYPAD_SELECT+1) << shift);
+            keycode_lut[AKEYCODE_BUTTON_5] |= ((RETRO_DEVICE_ID_JOYPAD_START+1) << shift);
+            keycode_lut[AKEYCODE_BUTTON_3] |= ((RETRO_DEVICE_ID_JOYPAD_A+1) << shift);
+            keycode_lut[AKEYCODE_BUTTON_1] |= ((RETRO_DEVICE_ID_JOYPAD_X) << shift);
+            keycode_lut[AKEYCODE_BUTTON_7] |= ((RETRO_DEVICE_ID_JOYPAD_L) << shift);
+            keycode_lut[AKEYCODE_BUTTON_8] |= ((RETRO_DEVICE_ID_JOYPAD_R) << shift);
+            keycode_lut[AKEYCODE_BUTTON_9] |= ((RETRO_DEVICE_ID_JOYPAD_L2) << shift);
+         }
+         else if (strstr(name_buf, "SideWinder"))
+         {
+            snprintf(msg, sizeof_msg, "RetroPad #%d is: Sidewinder.\n", port);
+            keycode_lut[AKEYCODE_BUTTON_A]  |= ((RETRO_DEVICE_ID_JOYPAD_B+1) << shift);
+            keycode_lut[AKEYCODE_BUTTON_X]  |= ((RETRO_DEVICE_ID_JOYPAD_Y+1) << shift);
+            keycode_lut[AKEYCODE_BUTTON_R2] |= ((RETRO_DEVICE_ID_JOYPAD_SELECT+1) << shift);
+            keycode_lut[AKEYCODE_BUTTON_L2] |= ((RETRO_DEVICE_ID_JOYPAD_START+1) << shift);
+            keycode_lut[AKEYCODE_BUTTON_B]  |= ((RETRO_DEVICE_ID_JOYPAD_A+1) << shift);
+            keycode_lut[AKEYCODE_BUTTON_Y]  |= ((RETRO_DEVICE_ID_JOYPAD_X+1) << shift);
+            keycode_lut[AKEYCODE_BUTTON_L1] |= ((RETRO_DEVICE_ID_JOYPAD_L+1) << shift);
+            keycode_lut[AKEYCODE_BUTTON_R1] |= ((RETRO_DEVICE_ID_JOYPAD_R+1) << shift);
+            keycode_lut[AKEYCODE_BUTTON_Z]  |= ((RETRO_DEVICE_ID_JOYPAD_L2+1) << shift);
+            keycode_lut[AKEYCODE_BUTTON_C]  |= ((RETRO_DEVICE_ID_JOYPAD_R2+1) << shift);
+            keycode_lut[AKEYCODE_BUTTON_11] |= ((RETRO_DEVICE_ID_JOYPAD_L3+1) << shift);
+            keycode_lut[AKEYCODE_BUTTON_12] |= ((RETRO_DEVICE_ID_JOYPAD_R3+1) << shift);
+         }
+      }
+      else if (strstr(name_buf, "WiseGroup") && strstr(name_buf, "Dual USB Joypad"))
+      {
+         snprintf(msg, sizeof_msg, "RetroPad #%d is: WiseGroup PS2 to USB.\n", port);
+         keycode_lut[AKEYCODE_BUTTON_3]  |= ((RETRO_DEVICE_ID_JOYPAD_B+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_4]  |= ((RETRO_DEVICE_ID_JOYPAD_Y+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_10] |= ((RETRO_DEVICE_ID_JOYPAD_SELECT+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_9]  |= ((RETRO_DEVICE_ID_JOYPAD_START+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_2]  |= ((RETRO_DEVICE_ID_JOYPAD_A+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_1]  |= ((RETRO_DEVICE_ID_JOYPAD_X+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_7]  |= ((RETRO_DEVICE_ID_JOYPAD_L+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_8]  |= ((RETRO_DEVICE_ID_JOYPAD_R+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_5]  |= ((RETRO_DEVICE_ID_JOYPAD_L2+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_6]  |= ((RETRO_DEVICE_ID_JOYPAD_R2+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_11] |= ((RETRO_DEVICE_ID_JOYPAD_L3+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_12] |= ((RETRO_DEVICE_ID_JOYPAD_R3+1) << shift);
+      }
+      else if (strstr(name_buf, "PLAYSTATION(R)3") || strstr(name_buf, "Dualshock3")
+            || strstr(name_buf,"Sixaxis") ||
+            (strstr(name_buf, "Gamepad 0") || strstr(name_buf, "Gamepad 1") || 
+               strstr(name_buf, "Gamepad 2") || strstr(name_buf, "Gamepad 3")))
+      {
+         bool do_invert = (strstr(name_buf, "Gamepad 0") || strstr(name_buf, "Gamepad 1") || 
+               strstr(name_buf, "Gamepad 2") || strstr(name_buf, "Gamepad 3"));
+
+         snprintf(msg, sizeof_msg, "RetroPad #%d is: DualShock3/Sixaxis.\n", port);
+         g_settings.input.dpad_emulation[port] = DPAD_EMULATION_NONE;
+         keycode_lut[AKEYCODE_DPAD_UP] |=  ((RETRO_DEVICE_ID_JOYPAD_UP+1)      << shift);
+         keycode_lut[AKEYCODE_DPAD_DOWN] |=  ((RETRO_DEVICE_ID_JOYPAD_DOWN+1)      << shift);
+         keycode_lut[AKEYCODE_DPAD_LEFT] |=  ((RETRO_DEVICE_ID_JOYPAD_LEFT+1)      << shift);
+         keycode_lut[AKEYCODE_DPAD_RIGHT] |=  ((RETRO_DEVICE_ID_JOYPAD_RIGHT+1)      << shift);
+
+         if (do_invert)
+         {
+            keycode_lut[AKEYCODE_BUTTON_A] |=  ((RETRO_DEVICE_ID_JOYPAD_B+1)      << shift);
+            keycode_lut[AKEYCODE_BUTTON_X] |=  ((RETRO_DEVICE_ID_JOYPAD_Y+1)      << shift);
+         }
+         else
+         {
+            keycode_lut[AKEYCODE_BUTTON_X] |=  ((RETRO_DEVICE_ID_JOYPAD_B+1)      << shift);
+            keycode_lut[AKEYCODE_BUTTON_A] |=  ((RETRO_DEVICE_ID_JOYPAD_Y+1)      << shift);
+         }
+         keycode_lut[AKEYCODE_BUTTON_SELECT] |=  ((RETRO_DEVICE_ID_JOYPAD_SELECT+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_START] |= ((RETRO_DEVICE_ID_JOYPAD_START+1)  << shift);
+
+         if (do_invert)
+         {
+            keycode_lut[AKEYCODE_BUTTON_Y] |=  ((RETRO_DEVICE_ID_JOYPAD_X+1)      << shift);
+            keycode_lut[AKEYCODE_BUTTON_B] |=  ((RETRO_DEVICE_ID_JOYPAD_A+1)      << shift);
+         }
+         else
+         {
+            keycode_lut[AKEYCODE_BUTTON_Y] |=  ((RETRO_DEVICE_ID_JOYPAD_A+1)      << shift);
+            keycode_lut[AKEYCODE_BUTTON_B] |=  ((RETRO_DEVICE_ID_JOYPAD_X+1)      << shift);
+         }
+         keycode_lut[AKEYCODE_BUTTON_L1] |=  ((RETRO_DEVICE_ID_JOYPAD_L+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_R1] |=  ((RETRO_DEVICE_ID_JOYPAD_R+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_L2] |=  ((RETRO_DEVICE_ID_JOYPAD_L2+1)     << shift);
+         keycode_lut[AKEYCODE_BUTTON_R2] |=  ((RETRO_DEVICE_ID_JOYPAD_R2+1)     << shift);
+         keycode_lut[AKEYCODE_BUTTON_THUMBL] |= ((RETRO_DEVICE_ID_JOYPAD_L3+1)     << shift);
+         keycode_lut[AKEYCODE_BUTTON_THUMBR] |= ((RETRO_DEVICE_ID_JOYPAD_R3+1)     << shift);
+      }
+      else if (strstr(name_buf, "MOGA"))
+      {
+         snprintf(msg, sizeof_msg, "RetroPad #%d is: MOGA.\n", port);
+         g_settings.input.dpad_emulation[port] = DPAD_EMULATION_NONE;
+         keycode_lut[AKEYCODE_DPAD_UP] |=  ((RETRO_DEVICE_ID_JOYPAD_UP+1)      << shift);
+         keycode_lut[AKEYCODE_DPAD_DOWN] |=  ((RETRO_DEVICE_ID_JOYPAD_DOWN+1)      << shift);
+         keycode_lut[AKEYCODE_DPAD_LEFT] |=  ((RETRO_DEVICE_ID_JOYPAD_LEFT+1)      << shift);
+         keycode_lut[AKEYCODE_DPAD_RIGHT] |=  ((RETRO_DEVICE_ID_JOYPAD_RIGHT+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_A] |=  ((RETRO_DEVICE_ID_JOYPAD_B+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_X] |=  ((RETRO_DEVICE_ID_JOYPAD_Y+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_SELECT] |=  ((RETRO_DEVICE_ID_JOYPAD_SELECT+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_START] |= ((RETRO_DEVICE_ID_JOYPAD_START+1)  << shift);
+         keycode_lut[AKEYCODE_BUTTON_B] |=  ((RETRO_DEVICE_ID_JOYPAD_A+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_Y] |=  ((RETRO_DEVICE_ID_JOYPAD_X+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_L1] |=  ((RETRO_DEVICE_ID_JOYPAD_L+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_R1] |=  ((RETRO_DEVICE_ID_JOYPAD_R+1)      << shift);
+      }
+      else if (strstr(name_buf, "Sony Navigation Controller"))
+      {
+         snprintf(msg, sizeof_msg, "RetroPad #%d is: PS Move Navi.\n", port);
+         keycode_lut[AKEYCODE_BUTTON_7]  |= ((RETRO_DEVICE_ID_JOYPAD_B+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_8]  |= ((RETRO_DEVICE_ID_JOYPAD_Y+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_5]  |= ((RETRO_DEVICE_ID_JOYPAD_X+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_6]  |= ((RETRO_DEVICE_ID_JOYPAD_A+1) << shift);
+
+         keycode_lut[AKEYCODE_BUTTON_11]  |= ((RETRO_DEVICE_ID_JOYPAD_L+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_9]  |= ((RETRO_DEVICE_ID_JOYPAD_L2+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_2]  |= ((RETRO_DEVICE_ID_JOYPAD_L3+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_15]  |= ((RETRO_DEVICE_ID_JOYPAD_R+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_14]  |= ((RETRO_DEVICE_ID_JOYPAD_R2+1) << shift);
+         keycode_lut[AKEYCODE_UNKNOWN]   |= ((RETRO_DEVICE_ID_JOYPAD_START+1) << shift);
+      }
+      else if (strstr(name_buf, "CYPRESS USB"))
+      {
+         snprintf(msg, sizeof_msg, "RetroPad #%d is: Saturn USB.\n", port);
+         keycode_lut[AKEYCODE_BUTTON_A]  |= ((RETRO_DEVICE_ID_JOYPAD_B+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_B]  |= ((RETRO_DEVICE_ID_JOYPAD_A+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_C]  |= ((RETRO_DEVICE_ID_JOYPAD_R2+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_X]  |= ((RETRO_DEVICE_ID_JOYPAD_Y+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_Y]  |= ((RETRO_DEVICE_ID_JOYPAD_X+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_Z]  |= ((RETRO_DEVICE_ID_JOYPAD_L2+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_L1]  |= ((RETRO_DEVICE_ID_JOYPAD_L+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_R1]  |= ((RETRO_DEVICE_ID_JOYPAD_R+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_L2]  |= ((RETRO_DEVICE_ID_JOYPAD_START+1) << shift);
+      }
+      else if (strstr(name_buf, "Mayflash Wii Classic"))
+      {
+         snprintf(msg, sizeof_msg, "RetroPad #%d is: Mayflash Wii Classic.\n", port);
+         g_settings.input.dpad_emulation[port] = DPAD_EMULATION_NONE;
+         keycode_lut[AKEYCODE_BUTTON_12] |=  ((RETRO_DEVICE_ID_JOYPAD_UP+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_14] |=  ((RETRO_DEVICE_ID_JOYPAD_DOWN+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_13] |=  ((RETRO_DEVICE_ID_JOYPAD_LEFT+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_15] |=  ((RETRO_DEVICE_ID_JOYPAD_RIGHT+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_4] |=  ((RETRO_DEVICE_ID_JOYPAD_Y+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_3] |=  ((RETRO_DEVICE_ID_JOYPAD_X+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_2] |=  ((RETRO_DEVICE_ID_JOYPAD_B+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_1] |= ((RETRO_DEVICE_ID_JOYPAD_A+1)  << shift);
+         keycode_lut[AKEYCODE_BUTTON_5] |=  ((RETRO_DEVICE_ID_JOYPAD_L+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_6] |=  ((RETRO_DEVICE_ID_JOYPAD_R+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_7] |=  ((RETRO_DEVICE_ID_JOYPAD_L2+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_8] |=  ((RETRO_DEVICE_ID_JOYPAD_R2+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_9] |=  ((RETRO_DEVICE_ID_JOYPAD_SELECT+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_10] |=  ((RETRO_DEVICE_ID_JOYPAD_START+1)      << shift);
+      }
+      else if (strstr(name_buf, "Toodles 2008 ChImp"))
+      {
+         snprintf(msg, sizeof_msg, "RetroPad #%d is: Chimp Board.\n", port);
+         keycode_lut[AKEYCODE_BUTTON_A] |=  ((RETRO_DEVICE_ID_JOYPAD_Y+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_X] |=  ((RETRO_DEVICE_ID_JOYPAD_X+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_Z] |=  ((RETRO_DEVICE_ID_JOYPAD_R+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_Y] |=  ((RETRO_DEVICE_ID_JOYPAD_L+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_B] |=  ((RETRO_DEVICE_ID_JOYPAD_B+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_C] |=  ((RETRO_DEVICE_ID_JOYPAD_A+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_R1] |=  ((RETRO_DEVICE_ID_JOYPAD_R2+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_L1] |=  ((RETRO_DEVICE_ID_JOYPAD_L2+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_L2] |=  ((RETRO_DEVICE_ID_JOYPAD_SELECT+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_R2] |=  ((RETRO_DEVICE_ID_JOYPAD_START+1)      << shift);
+      }
+      else if (strstr(name_buf, "keypad-game-zeus"))
+      {
+         volume_enable = false;
+         snprintf(msg, sizeof_msg, "RetroPad #%d is: Xperia Play.\n", port);
+         keycode_lut[AKEYCODE_DPAD_CENTER] |=  ((RETRO_DEVICE_ID_JOYPAD_B+1)      << shift);
+         keycode_lut[AKEYCODE_BACK] |=  ((RETRO_DEVICE_ID_JOYPAD_A+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_X] |=  ((RETRO_DEVICE_ID_JOYPAD_Y+1)      << shift);
+         keycode_lut[AKEYCODE_BUTTON_Y] |=  ((RETRO_DEVICE_ID_JOYPAD_X+1)      << shift);
+         keycode_lut[AKEYCODE_DPAD_UP] |= ((RETRO_DEVICE_ID_JOYPAD_UP+1) << shift);
+         keycode_lut[AKEYCODE_DPAD_DOWN] |= ((RETRO_DEVICE_ID_JOYPAD_DOWN+1) << shift);
+         keycode_lut[AKEYCODE_DPAD_LEFT] |= ((RETRO_DEVICE_ID_JOYPAD_LEFT+1) << shift);
+         keycode_lut[AKEYCODE_DPAD_RIGHT] |= ((RETRO_DEVICE_ID_JOYPAD_RIGHT+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_SELECT] |= ((RETRO_DEVICE_ID_JOYPAD_SELECT+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_START] |= ((RETRO_DEVICE_ID_JOYPAD_START+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_L1] |= ((RETRO_DEVICE_ID_JOYPAD_L+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_R1] |= ((RETRO_DEVICE_ID_JOYPAD_R+1) << shift);
+      }
+      if (strstr(current_ime, "com.ccpcreations.android.WiiUseAndroid"))
+      {
+         // Player 1
+         snprintf(msg, sizeof_msg, "RetroPad #%d, %d, %d, %d is: Wiimote (IME).\n", 
+               port, port + 1, port + 2, port + 3);
+         snprintf(name_buf, sizeof(name_buf), "ccpcreations WiiUse");
+         g_settings.input.dpad_emulation[port] = DPAD_EMULATION_NONE;
+         keycode_lut[AKEYCODE_DPAD_UP]   |= ((RETRO_DEVICE_ID_JOYPAD_UP+1)    << shift);
+         keycode_lut[AKEYCODE_DPAD_DOWN] |= ((RETRO_DEVICE_ID_JOYPAD_DOWN+1)    << shift);
+         keycode_lut[AKEYCODE_DPAD_LEFT] |= ((RETRO_DEVICE_ID_JOYPAD_LEFT+1)    << shift);
+         keycode_lut[AKEYCODE_DPAD_RIGHT]|= ((RETRO_DEVICE_ID_JOYPAD_RIGHT+1)    << shift);
+         keycode_lut[AKEYCODE_1]         |= ((RETRO_DEVICE_ID_JOYPAD_B+1)      << shift);
+         keycode_lut[AKEYCODE_2]         |= ((RETRO_DEVICE_ID_JOYPAD_A+1)      << shift);
+         keycode_lut[AKEYCODE_3]         |= ((RETRO_DEVICE_ID_JOYPAD_UP+1)      << shift);
+         keycode_lut[AKEYCODE_4]         |= ((RETRO_DEVICE_ID_JOYPAD_DOWN+1)    << shift);
+         keycode_lut[AKEYCODE_5]         |= ((RETRO_DEVICE_ID_JOYPAD_LEFT+1)    << shift);
+         keycode_lut[AKEYCODE_6]         |= ((RETRO_DEVICE_ID_JOYPAD_RIGHT+1)   << shift);
+         keycode_lut[AKEYCODE_M]         |= ((RETRO_DEVICE_ID_JOYPAD_SELECT+1)  << shift);
+         keycode_lut[AKEYCODE_P]         |= ((RETRO_DEVICE_ID_JOYPAD_START+1)   << shift);
+         keycode_lut[AKEYCODE_E]         |= ((RETRO_DEVICE_ID_JOYPAD_Y+1)       << shift);
+         keycode_lut[AKEYCODE_B]         |= ((RETRO_DEVICE_ID_JOYPAD_X+1)       << shift);
+         keycode_lut[AKEYCODE_F]         |= ((RETRO_DEVICE_ID_JOYPAD_B+1)       << shift);
+         keycode_lut[AKEYCODE_G]         |= ((RETRO_DEVICE_ID_JOYPAD_A+1)       << shift);
+         keycode_lut[AKEYCODE_C]         |= ((RETRO_DEVICE_ID_JOYPAD_L+1)       << shift);
+         keycode_lut[AKEYCODE_LEFT_BRACKET]  |= ((RETRO_DEVICE_ID_JOYPAD_L2+1)       << shift);
+         keycode_lut[AKEYCODE_RIGHT_BRACKET] |= ((RETRO_DEVICE_ID_JOYPAD_R2+1)       << shift);
+         keycode_lut[AKEYCODE_Z]         |= ((RETRO_DEVICE_ID_JOYPAD_R+1)       << shift);
+         keycode_lut[AKEYCODE_H]         |= ((RARCH_RESET+1)                    << shift);
+         keycode_lut[AKEYCODE_W]         |= ((RETRO_DEVICE_ID_JOYPAD_UP+1)      << shift);
+         keycode_lut[AKEYCODE_S]         |= ((RETRO_DEVICE_ID_JOYPAD_DOWN+1)    << shift);
+         keycode_lut[AKEYCODE_A]         |= ((RETRO_DEVICE_ID_JOYPAD_LEFT+1)    << shift);
+         keycode_lut[AKEYCODE_D]         |= ((RETRO_DEVICE_ID_JOYPAD_RIGHT+1)    << shift);
+         keycode_lut[AKEYCODE_C]         |= ((RETRO_DEVICE_ID_JOYPAD_A+1)    << shift);
+         keycode_lut[AKEYCODE_Z]         |= ((RETRO_DEVICE_ID_JOYPAD_B+1)    << shift);
+
+         //player 2
+         shift += 8;
+         volume_enable = false;
+         keycode_lut[AKEYCODE_I]   |= ((RETRO_DEVICE_ID_JOYPAD_UP+1)    << shift);
+         keycode_lut[AKEYCODE_K] |= ((RETRO_DEVICE_ID_JOYPAD_DOWN+1)    << shift);
+         keycode_lut[AKEYCODE_J] |= ((RETRO_DEVICE_ID_JOYPAD_LEFT+1)    << shift);
+         keycode_lut[AKEYCODE_O]|= ((RETRO_DEVICE_ID_JOYPAD_RIGHT+1)    << shift);
+         keycode_lut[AKEYCODE_COMMA] |= ((RETRO_DEVICE_ID_JOYPAD_B+1)      << shift);
+         keycode_lut[AKEYCODE_PERIOD] |= ((RETRO_DEVICE_ID_JOYPAD_A+1)      << shift);
+         keycode_lut[AKEYCODE_VOLUME_UP] |= ((RETRO_DEVICE_ID_JOYPAD_UP+1)      << shift);
+         keycode_lut[AKEYCODE_VOLUME_DOWN] |= ((RETRO_DEVICE_ID_JOYPAD_DOWN+1)      << shift);
+         keycode_lut[AKEYCODE_MEDIA_PREVIOUS] |= ((RETRO_DEVICE_ID_JOYPAD_LEFT+1)      << shift);
+         keycode_lut[AKEYCODE_MEDIA_NEXT] |= ((RETRO_DEVICE_ID_JOYPAD_RIGHT+1)      << shift);
+         keycode_lut[AKEYCODE_MEDIA_PLAY] |= ((RETRO_DEVICE_ID_JOYPAD_X+1)      << shift);
+         keycode_lut[AKEYCODE_MEDIA_STOP] |= ((RETRO_DEVICE_ID_JOYPAD_Y+1)      << shift);
+         keycode_lut[AKEYCODE_ENDCALL] |= ((RETRO_DEVICE_ID_JOYPAD_A+1)      << shift);
+         keycode_lut[AKEYCODE_CALL] |= ((RETRO_DEVICE_ID_JOYPAD_B+1)      << shift);
+         keycode_lut[AKEYCODE_PLUS] |= ((RETRO_DEVICE_ID_JOYPAD_START+1)      << shift);
+         keycode_lut[AKEYCODE_MINUS] |= ((RETRO_DEVICE_ID_JOYPAD_SELECT+1)      << shift);
+         keycode_lut[AKEYCODE_BACKSLASH] |= ((RARCH_RESET+1)      << shift);
+         keycode_lut[AKEYCODE_L] |= ((RETRO_DEVICE_ID_JOYPAD_L+1)      << shift);
+         keycode_lut[AKEYCODE_R] |= ((RETRO_DEVICE_ID_JOYPAD_R+1)      << shift);
+         keycode_lut[AKEYCODE_SEARCH] |= ((RETRO_DEVICE_ID_JOYPAD_L2+1)      << shift);
+         keycode_lut[AKEYCODE_TAB] |= ((RETRO_DEVICE_ID_JOYPAD_R2+1)      << shift);
+
+         //player 3
+         shift += 8;
+         keycode_lut[AKEYCODE_PAGE_UP]   |= ((RETRO_DEVICE_ID_JOYPAD_UP+1)    << shift);
+         keycode_lut[AKEYCODE_PAGE_DOWN] |= ((RETRO_DEVICE_ID_JOYPAD_DOWN+1)    << shift);
+         keycode_lut[AKEYCODE_MEDIA_REWIND] |= ((RETRO_DEVICE_ID_JOYPAD_LEFT+1)    << shift);
+         keycode_lut[AKEYCODE_MEDIA_FAST_FORWARD]|= ((RETRO_DEVICE_ID_JOYPAD_RIGHT+1)    << shift);
+         keycode_lut[AKEYCODE_SOFT_LEFT]|= ((RETRO_DEVICE_ID_JOYPAD_B+1)    << shift);
+         keycode_lut[AKEYCODE_SOFT_RIGHT]|= ((RETRO_DEVICE_ID_JOYPAD_A+1)    << shift);
+         keycode_lut[AKEYCODE_BUTTON_THUMBR]|= ((RETRO_DEVICE_ID_JOYPAD_START+1)    << shift);
+         keycode_lut[AKEYCODE_BUTTON_THUMBL]|= ((RETRO_DEVICE_ID_JOYPAD_SELECT+1)    << shift);
+         keycode_lut[AKEYCODE_SPACE]|= ((RETRO_DEVICE_ID_JOYPAD_UP+1)    << shift);
+         keycode_lut[AKEYCODE_SYM]|= ((RETRO_DEVICE_ID_JOYPAD_DOWN+1)    << shift);
+         keycode_lut[AKEYCODE_EXPLORER]|= ((RETRO_DEVICE_ID_JOYPAD_LEFT+1)    << shift);
+         keycode_lut[AKEYCODE_ENVELOPE]|= ((RETRO_DEVICE_ID_JOYPAD_RIGHT+1)    << shift);
+         keycode_lut[AKEYCODE_BUTTON_X]|= ((RETRO_DEVICE_ID_JOYPAD_X+1)    << shift);
+         keycode_lut[AKEYCODE_BUTTON_Y]|= ((RETRO_DEVICE_ID_JOYPAD_Y+1)    << shift);
+         keycode_lut[AKEYCODE_BUTTON_A]|= ((RETRO_DEVICE_ID_JOYPAD_A+1)    << shift);
+         keycode_lut[AKEYCODE_BUTTON_B]|= ((RETRO_DEVICE_ID_JOYPAD_B+1)    << shift);
+         keycode_lut[AKEYCODE_BUTTON_L1]|= ((RETRO_DEVICE_ID_JOYPAD_L+1)    << shift);
+         keycode_lut[AKEYCODE_BUTTON_R1]|= ((RETRO_DEVICE_ID_JOYPAD_R+1)    << shift);
+         keycode_lut[AKEYCODE_BUTTON_L2]|= ((RETRO_DEVICE_ID_JOYPAD_L2+1)    << shift);
+         keycode_lut[AKEYCODE_BUTTON_R2]|= ((RETRO_DEVICE_ID_JOYPAD_R2+1)    << shift);
+
+         //player 4
+         shift += 8;
+         keycode_lut[AKEYCODE_N]   |= ((RETRO_DEVICE_ID_JOYPAD_UP+1)    << shift);
+         keycode_lut[AKEYCODE_Q] |= ((RETRO_DEVICE_ID_JOYPAD_DOWN+1)    << shift);
+         keycode_lut[AKEYCODE_T] |= ((RETRO_DEVICE_ID_JOYPAD_LEFT+1)    << shift);
+         keycode_lut[AKEYCODE_APOSTROPHE]|= ((RETRO_DEVICE_ID_JOYPAD_RIGHT+1)    << shift);
+         keycode_lut[AKEYCODE_NOTIFICATION]|= ((RETRO_DEVICE_ID_JOYPAD_B+1)    << shift);
+         keycode_lut[AKEYCODE_MUTE]|= ((RETRO_DEVICE_ID_JOYPAD_A+1)    << shift);
+         keycode_lut[AKEYCODE_BUTTON_START]|= ((RETRO_DEVICE_ID_JOYPAD_START+1)    << shift);
+         keycode_lut[AKEYCODE_BUTTON_SELECT]|= ((RETRO_DEVICE_ID_JOYPAD_SELECT+1)    << shift);
+         keycode_lut[AKEYCODE_CLEAR]|= ((RARCH_RESET+1)    << shift);
+         keycode_lut[AKEYCODE_CAPS_LOCK]   |= ((RETRO_DEVICE_ID_JOYPAD_UP+1)    << shift);
+         keycode_lut[AKEYCODE_SCROLL_LOCK] |= ((RETRO_DEVICE_ID_JOYPAD_DOWN+1)    << shift);
+         //keycode_lut[AKEYCODE_T] |= ((RETRO_DEVICE_ID_JOYPAD_LEFT+1)    << shift); -- Left meta
+         //keycode_lut[AKEYCODE_APOSTROPHE]|= ((RETRO_DEVICE_ID_JOYPAD_RIGHT+1)    << shift); -- right meta
+         keycode_lut[AKEYCODE_META_FUNCTION_ON] |= ((RETRO_DEVICE_ID_JOYPAD_X+1) << shift);
+         keycode_lut[AKEYCODE_SYSRQ] |= ((RETRO_DEVICE_ID_JOYPAD_Y+1) << shift);
+         keycode_lut[AKEYCODE_BREAK] |= ((RETRO_DEVICE_ID_JOYPAD_A+1) << shift);
+         keycode_lut[AKEYCODE_MOVE_HOME] |= ((RETRO_DEVICE_ID_JOYPAD_B+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_C] |= ((RETRO_DEVICE_ID_JOYPAD_L+1) << shift);
+         keycode_lut[AKEYCODE_BUTTON_Z] |= ((RETRO_DEVICE_ID_JOYPAD_R+1) << shift);
+         keycode_lut[AKEYCODE_GRAVE] |= ((RETRO_DEVICE_ID_JOYPAD_L2+1) << shift);
+         keycode_lut[AKEYCODE_MEDIA_PAUSE] |= ((RETRO_DEVICE_ID_JOYPAD_R2+1) << shift);
+      }
+      else if (source == AINPUT_SOURCE_TOUCHSCREEN)
+      {
+         snprintf(msg, sizeof_msg, "RetroPad #%d is: Touchscreen.\n", port);
+      }
+      else if (source == AINPUT_SOURCE_MOUSE)
+      {
+         snprintf(msg, sizeof_msg, "RetroPad #%d is: Mouse.\n", port);
+      }
+      else if (source == AINPUT_SOURCE_KEYBOARD)
+      {
+         snprintf(msg, sizeof_msg, "RetroPad #%d is: Keyboard.\n", port);
+         // Keyboard
+         // TODO: Map L2/R2/L3/R3
+
+         keycode_lut[AKEYCODE_Z] |= ((RETRO_DEVICE_ID_JOYPAD_B+1) << shift);
+         keycode_lut[AKEYCODE_A] |= ((RETRO_DEVICE_ID_JOYPAD_Y+1) << shift);
+         keycode_lut[AKEYCODE_SHIFT_RIGHT] |= ((RETRO_DEVICE_ID_JOYPAD_SELECT+1) << shift);
+         keycode_lut[AKEYCODE_ENTER] |= ((RETRO_DEVICE_ID_JOYPAD_START+1) << shift);
+         keycode_lut[AKEYCODE_DPAD_UP] |= ((RETRO_DEVICE_ID_JOYPAD_UP+1) << shift);
+         keycode_lut[AKEYCODE_DPAD_DOWN] |= ((RETRO_DEVICE_ID_JOYPAD_DOWN+1) << shift);
+         keycode_lut[AKEYCODE_DPAD_LEFT] |= ((RETRO_DEVICE_ID_JOYPAD_LEFT+1) << shift);
+         keycode_lut[AKEYCODE_DPAD_RIGHT] |= ((RETRO_DEVICE_ID_JOYPAD_RIGHT+1) << shift);
+         keycode_lut[AKEYCODE_X] |= ((RETRO_DEVICE_ID_JOYPAD_A+1) << shift);
+         keycode_lut[AKEYCODE_S] |= ((RETRO_DEVICE_ID_JOYPAD_X+1) << shift);
+         keycode_lut[AKEYCODE_Q] |= ((RETRO_DEVICE_ID_JOYPAD_L+1) << shift);
+         keycode_lut[AKEYCODE_W] |= ((RETRO_DEVICE_ID_JOYPAD_R+1) << shift);
+
+         /* Misc control scheme */
+         keycode_lut[AKEYCODE_F2] |= ((RARCH_SAVE_STATE_KEY+1) << shift);
+         keycode_lut[AKEYCODE_F4] |= ((RARCH_LOAD_STATE_KEY+1) << shift);
+         keycode_lut[AKEYCODE_F7] |= ((RARCH_STATE_SLOT_PLUS+1) << shift);
+         keycode_lut[AKEYCODE_F6] |= ((RARCH_STATE_SLOT_MINUS+1) << shift);
+         keycode_lut[AKEYCODE_SPACE] |= ((RARCH_FAST_FORWARD_KEY+1) << shift);
+         keycode_lut[AKEYCODE_L] |= ((RARCH_FAST_FORWARD_HOLD_KEY+1) << shift);
+         keycode_lut[AKEYCODE_BREAK] |= ((RARCH_PAUSE_TOGGLE+1) << shift);
+         keycode_lut[AKEYCODE_K] |= ((RARCH_FRAMEADVANCE+1) << shift);
+         keycode_lut[AKEYCODE_H] |= ((RARCH_RESET+1) << shift);
+         keycode_lut[AKEYCODE_R] |= ((RARCH_REWIND+1) << shift);
+         keycode_lut[AKEYCODE_F9] |= ((RARCH_MUTE+1) << shift);
+
+         keycode_lut[AKEYCODE_ESCAPE] |= ((RARCH_QUIT_KEY+1) << shift);
+         keycode_lut[AKEYCODE_BACK] |= ((RARCH_QUIT_KEY+1) << shift);
+      }
+   }
+
+   if (name_buf[0] != 0)
+      RARCH_LOG("Device %d: %s, port: %d.\n", id, name_buf, port);
+
+   if (msg[0] == 0 && name_buf[0] != 0)
+      snprintf(msg, sizeof_msg, "HID [%s] unbound.\n", name_buf);
+}

android/native/jni/input_autodetect.h

@@ -0,0 +1,69 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
+ *  Copyright (C) 2011-2013 - Daniel De Matteis
+ * 
+ *  RetroArch 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.
+ *
+ *  RetroArch 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 RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _ANDROID_INPUT_AUTODETECT_H
+#define _ANDROID_INPUT_AUTODETECT_H
+
+#define MAX_PADS 8
+
+#define AKEY_EVENT_NO_ACTION 255
+
+enum {
+   AKEYCODE_META_FUNCTION_ON = 8,
+   AKEYCODE_ESCAPE          = 111,
+   AKEYCODE_CAPS_LOCK       = 115,
+   AKEYCODE_SCROLL_LOCK     = 116,
+   AKEYCODE_SYSRQ           = 120,
+   AKEYCODE_BREAK           = 121,
+   AKEYCODE_MOVE_HOME       = 122,
+   AKEYCODE_MEDIA_PLAY      = 126,
+   AKEYCODE_MEDIA_PAUSE     = 127,
+   AKEYCODE_F2              = 132,
+   AKEYCODE_F3              = 133,
+   AKEYCODE_F4              = 134,
+   AKEYCODE_F5              = 135,
+   AKEYCODE_F6              = 136,
+   AKEYCODE_F7              = 137,
+   AKEYCODE_F8              = 138,
+   AKEYCODE_F9              = 139,
+   AKEYCODE_BUTTON_1        = 188,
+   AKEYCODE_BUTTON_2        = 189,
+   AKEYCODE_BUTTON_3        = 190,
+   AKEYCODE_BUTTON_4        = 191,
+   AKEYCODE_BUTTON_5        = 192,
+   AKEYCODE_BUTTON_6        = 193,
+   AKEYCODE_BUTTON_7        = 194,
+   AKEYCODE_BUTTON_8        = 195,
+   AKEYCODE_BUTTON_9        = 196,
+   AKEYCODE_BUTTON_10       = 197,
+   AKEYCODE_BUTTON_11       = 198,
+   AKEYCODE_BUTTON_12       = 199,
+   AKEYCODE_BUTTON_13       = 200,
+   AKEYCODE_BUTTON_14       = 201,
+   AKEYCODE_BUTTON_15       = 202,
+   AKEYCODE_BUTTON_16       = 203,
+   AKEYCODE_ASSIST          = 219,
+};
+
+#define LAST_KEYCODE AKEYCODE_ASSIST
+
+extern uint64_t keycode_lut[LAST_KEYCODE];
+extern bool volume_enable;
+
+void input_autodetect_init (void);
+void input_autodetect_setup (void *data, char *msg, size_t sizeof_msg, unsigned port, unsigned id, int source);
+
+#endif

android/native/jni/jni_macros.h

@@ -0,0 +1,82 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
+ *  Copyright (C) 2011-2013 - Daniel De Matteis
+ * 
+ *  RetroArch 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.
+ *
+ *  RetroArch 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 RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _JNI_MACROS_H
+#define _JNI_MACROS_H
+
+#include <jni.h>
+
+struct jni_params
+{
+   JavaVM *java_vm;
+   JNIEnv *env;
+   jobject class_obj;
+   char class_name[128];
+   char method_name[128];
+   char method_signature[128];
+};
+
+struct jni_out_params_char
+{
+   char *out;
+   size_t out_sizeof;
+   char in[128];
+};
+
+#define JNI_EXCEPTION(env) \
+   if ((*env)->ExceptionOccurred(env)) \
+   { \
+      (*env)->ExceptionDescribe(env); \
+      (*env)->ExceptionClear(env); \
+   }
+
+#define FIND_CLASS(env, var, classname) \
+   var = (*env)->FindClass(env, classname); \
+   JNI_EXCEPTION(env)
+
+#define GET_OBJECT_CLASS(env, var, clazz_obj) \
+   var = (*env)->GetObjectClass(env, clazz_obj); \
+   JNI_EXCEPTION(env)
+
+#define GET_FIELD_ID(env, var, clazz, fieldName, fieldDescriptor) \
+   var = (*env)->GetFieldID(env, clazz, fieldName, fieldDescriptor); \
+   JNI_EXCEPTION(env)
+
+#define GET_METHOD_ID(env, var, clazz, methodName, fieldDescriptor) \
+   var = (*env)->GetMethodID(env, clazz, methodName, fieldDescriptor); \
+   JNI_EXCEPTION(env)
+
+#define GET_STATIC_METHOD_ID(env, var, clazz, methodName, fieldDescriptor) \
+   var = (*env)->GetStaticMethodID(env, clazz, methodName, fieldDescriptor); \
+   JNI_EXCEPTION(env)
+
+#define CALL_OBJ_METHOD(env, var, clazz_obj, methodId) \
+   var = (*env)->CallObjectMethod(env, clazz_obj, methodId); \
+   JNI_EXCEPTION(env)
+
+#define CALL_OBJ_STATIC_METHOD(env, var, clazz, methodId) \
+   var = (*env)->CallStaticObjectMethod(env, clazz, methodId); \
+   JNI_EXCEPTION(env)
+
+#define CALL_OBJ_STATIC_METHOD_PARAM(env, var, clazz, methodId, ...) \
+   var = (*env)->CallStaticObjectMethod(env, clazz, methodId, __VA_ARGS__); \
+   JNI_EXCEPTION(env)
+
+#define CALL_OBJ_METHOD_PARAM(env, var, clazz_obj, methodId, ...) \
+   var = (*env)->CallObjectMethod(env, clazz_obj, methodId, __VA_ARGS__); \
+   JNI_EXCEPTION(env)
+
+#endif

android/native/res/values/strings.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">NativeActivity</string>
+</resources>

android/phoenix/.classpath

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
+	<classpathentry kind="output" path="bin/classes"/>
+</classpath>

android/phoenix/.gitignore

@@ -0,0 +1,5 @@
+/gen
+/bin
+/libs/*/*
+/obj
+/jni/modules/*.so

android/phoenix/.project

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>RetroArch</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

android/phoenix/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.6

android/phoenix/AndroidManifest.xml

@@ -0,0 +1,39 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="org.retroarch"
+    android:versionCode="1"
+    android:versionName="0.9.8" >
+	<uses-feature android:glEsVersion="0x00020000" />
+    <uses-sdk
+        android:minSdkVersion="11"
+        android:targetSdkVersion="16" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
+    
+    <application
+        android:allowBackup="true"
+        android:icon="@drawable/ic_launcher"
+        android:label="@string/app_name" >
+        <activity android:name="org.retroarch.browser.RetroArch">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+        
+        <activity android:name="org.retroarch.browser.SettingsActivity"></activity>
+        <activity android:name="org.retroarch.browser.DirectoryActivity"></activity>
+        <activity android:name="org.retroarch.browser.ROMActivity"></activity>
+        
+        <activity android:name="org.retroarch.browser.ShaderActivity"></activity>
+        <activity android:name="org.retroarch.browser.Shader2Activity"></activity>
+        <activity android:name="org.retroarch.browser.OverlayActivity"></activity>
+        <activity android:name="org.retroarch.browser.ROMDirActivity"></activity>
+        <activity android:name="org.retroarch.browser.SRMDirActivity"></activity>
+        <activity android:name="org.retroarch.browser.StateDirActivity"></activity>
+        
+        <activity android:name="android.app.NativeActivity" android:configChanges="mcc|mnc|locale|touchscreen|keyboard|keyboardHidden|navigation|orientation|screenLayout|uiMode|screenSize|smallestScreenSize|fontScale">
+        	<meta-data android:name="android.app.lib_name" android:value="retroarch-activity" />
+         	<meta-data android:name="android.app.func_name" android:value="ANativeActivity_onCreate" />
+        </activity>
+    </application>
+</manifest>

android/phoenix/ant.properties

@@ -0,0 +1,17 @@
+# This file is used to override default values used by the Ant build system.
+#
+# This file must be checked into Version Control Systems, as it is
+# integral to the build system of your project.
+
+# This file is only used by the Ant script.
+
+# You can use this to override default values such as
+#  'source.dir' for the location of your java source folder and
+#  'out.dir' for the location of your output folder.
+
+# You can also use it define how the release builds are signed by declaring
+# the following properties:
+#  'key.store' for the location of your keystore and
+#  'key.alias' for the name of the key to use.
+# The password will be asked during the build when you use the 'release' target.
+

android/phoenix/build.xml

@@ -0,0 +1,92 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project name="retroarch" default="help">
+
+    <!-- The local.properties file is created and updated by the 'android' tool.
+         It contains the path to the SDK. It should *NOT* be checked into
+         Version Control Systems. -->
+    <property file="local.properties" />
+
+    <!-- The ant.properties file can be created by you. It is only edited by the
+         'android' tool to add properties to it.
+         This is the place to change some Ant specific build properties.
+         Here are some properties you may want to change/update:
+
+         source.dir
+             The name of the source directory. Default is 'src'.
+         out.dir
+             The name of the output directory. Default is 'bin'.
+
+         For other overridable properties, look at the beginning of the rules
+         files in the SDK, at tools/ant/build.xml
+
+         Properties related to the SDK location or the project target should
+         be updated using the 'android' tool with the 'update' action.
+
+         This file is an integral part of the build system for your
+         application and should be checked into Version Control Systems.
+
+         -->
+    <property file="ant.properties" />
+
+    <!-- if sdk.dir was not set from one of the property file, then
+         get it from the ANDROID_HOME env var.
+         This must be done before we load project.properties since
+         the proguard config can use sdk.dir -->
+    <property environment="env" />
+    <condition property="sdk.dir" value="${env.ANDROID_HOME}">
+        <isset property="env.ANDROID_HOME" />
+    </condition>
+
+    <!-- The project.properties file is created and updated by the 'android'
+         tool, as well as ADT.
+
+         This contains project specific properties such as project target, and library
+         dependencies. Lower level build properties are stored in ant.properties
+         (or in .classpath for Eclipse projects).
+
+         This file is an integral part of the build system for your
+         application and should be checked into Version Control Systems. -->
+    <loadproperties srcFile="project.properties" />
+
+    <!-- quick check on sdk.dir -->
+    <fail
+            message="sdk.dir is missing. Make sure to generate local.properties using 'android update project' or to inject it through the ANDROID_HOME environment variable."
+            unless="sdk.dir"
+    />
+
+    <!--
+        Import per project custom build rules if present at the root of the project.
+        This is the place to put custom intermediary targets such as:
+            -pre-build
+            -pre-compile
+            -post-compile (This is typically used for code obfuscation.
+                           Compiled code location: ${out.classes.absolute.dir}
+                           If this is not done in place, override ${out.dex.input.absolute.dir})
+            -post-package
+            -post-build
+            -pre-clean
+    -->
+    <import file="custom_rules.xml" optional="true" />
+
+    <!-- Import the actual build file.
+
+         To customize existing targets, there are two options:
+         - Customize only one target:
+             - copy/paste the target into this file, *before* the
+               <import> task.
+             - customize it to your needs.
+         - Customize the whole content of build.xml
+             - copy/paste the content of the rules files (minus the top node)
+               into this file, replacing the <import> task.
+             - customize to your needs.
+
+         ***********************
+         ****** IMPORTANT ******
+         ***********************
+         In all cases you must update the value of version-tag below to read 'custom' instead of an integer,
+         in order to avoid having your file be overridden by tools such as "android update project"
+    -->
+    <!-- version-tag: 1 -->
+    <import file="${sdk.dir}/tools/ant/build.xml" />
+
+</project>

android/phoenix/jni/Android.mk

@@ -0,0 +1,12 @@
+LOCAL_PATH := $(call my-dir)
+include $(LOCAL_PATH)/../../native/jni/Android.mk
+
+# Include all present sub-modules
+FOCAL_PATH := $(LOCAL_PATH)
+
+define function
+$(eval RETRO_MODULE_OBJECT := $(1))
+$(eval include $(FOCAL_PATH)/modules/Android.mk)
+endef
+
+$(foreach m,$(wildcard $(FOCAL_PATH)/modules/*.so),$(eval $(call function,$(m))))

android/phoenix/jni/Application.mk

@@ -0,0 +1,2 @@
+APP_PLATFORM := android-9
+APP_ABI := all

android/phoenix/jni/modules/Android.mk

@@ -0,0 +1,6 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := $(notdir $(RETRO_MODULE_OBJECT))
+LOCAL_SRC_FILES := $(notdir $(RETRO_MODULE_OBJECT))
+include $(PREBUILT_SHARED_LIBRARY)

android/phoenix/proguard-project.txt

@@ -0,0 +1,20 @@
+# To enable ProGuard in your project, edit project.properties
+# to define the proguard.config property as described in that file.
+#
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in ${sdk.dir}/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the ProGuard
+# include property in project.properties.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}

android/phoenix/project.properties

@@ -0,0 +1,14 @@
+# This file is automatically generated by Android Tools.
+# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
+#
+# This file must be checked in Version Control Systems.
+#
+# To customize properties used by the Ant build system edit
+# "ant.properties", and override values to adapt the script to your
+# project structure.
+#
+# To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home):
+#proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt
+
+# Project target.
+target=android-16

android/phoenix/res/layout/icon_grid_item.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="fill_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical" >
+
+    <ImageView
+        android:id="@+id/icon"
+        android:layout_width="192dp"
+        android:layout_height="192dp"
+        android:layout_gravity="center"
+        android:contentDescription="@string/file_type_icon"
+        android:padding="8dp" />
+
+    <TextView
+        android:id="@+id/name"
+        android:layout_width="wrap_content"
+        android:layout_height="0dp"
+        android:layout_gravity="center"
+        android:layout_weight="0.5"
+        android:textSize="18sp" />
+
+</LinearLayout>

android/phoenix/res/layout/icon_grid_list.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<GridView xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/list"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:numColumns="2" >
+
+</GridView>

android/phoenix/res/layout/line_list.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ListView xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/list"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content" >
+</ListView>
+

android/phoenix/res/layout/line_list_item.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="horizontal"
+    android:layout_width="fill_parent"
+    android:layout_height="48dp">
+
+    <ImageView
+        android:id="@+id/icon"
+        android:layout_width="48dp"
+        android:layout_height="48dp"
+        android:contentDescription="@string/file_type_icon"
+        android:padding="8dp" />
+
+    <TextView
+        android:id="@+id/name"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_gravity="center"
+        android:layout_weight="0.5"
+        android:textSize="18sp" />
+
+</LinearLayout>

android/phoenix/res/menu/context_menu.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<menu xmlns:android="http://schemas.android.com/apk/res/android" >
+    <item android:id="@+id/rarch_settings" android:title="@string/rarch_settings" android:showAsAction="ifRoom" />
+    <item android:id="@+id/input_method_select" android:title="@string/input_method" android:showAsAction="ifRoom" />
+    <item android:id="@+id/retroarch_guide" android:title="@string/retroarch_guide"></item>
+    <item android:id="@+id/cores_guide" android:title="@string/cores_guide"></item>
+    <item android:id="@+id/overlay_guide" android:title="@string/overlay_guide"></item>
+    <item android:id="@+id/shader_pack" android:title="@string/shader_pack"></item>
+</menu>

android/phoenix/res/menu/directory_list.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<menu xmlns:android="http://schemas.android.com/apk/res/android" >
+    <item android:id="@+id/settings"
+        android:title="@string/settings"
+        android:icon="@drawable/ic_file"
+        android:showAsAction="ifRoom" />
+</menu>

android/phoenix/res/values/array.xml

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string-array name="aspect_ratios">
+        <item>Full screen</item>
+        <item>Auto</item>
+        <item>Square pixel</item>
+        <item>4:3</item>
+        <item>16:9</item>
+        <item>16:10</item>
+        <item>8:7</item>
+    </string-array>
+    
+    <string-array name="aspect_values">
+        <item>full</item>
+        <item>auto</item>
+        <item>square</item>
+        <item>1.33333</item>
+        <item>1.77777</item>
+        <item>1.60000</item>
+        <item>1.14286</item>
+    </string-array>
+    
+    <string-array name="fbo_scales">
+        <item>1.0x</item>
+        <item>2.0x</item>
+        <item>3.0x</item>
+        <item>4.0x</item>
+        <item>5.0x</item>
+    </string-array>
+    
+    <string-array name="fbo_scale_values">
+        <item>1.0</item>
+        <item>2.0</item>
+        <item>3.0</item>
+        <item>4.0</item>
+        <item>5.0</item>
+    </string-array>
+</resources>

android/phoenix/res/values/strings.xml

@@ -0,0 +1,17 @@
+<resources>
+
+    <string name="app_name">RetroArch</string>
+    <string name="input_method">Input Method</string>
+    <string name="file_type_icon">File type icon</string>
+    <string name="video_settings">Video Settings</string>
+    <string name="rarch_settings">RetroArch Settings</string>
+    <string name="audio_settings">Audio Settings</string>
+    <string name="input_settings">Input Settings</string>
+    <string name="general_settings">General Settings</string>
+    <string name="settings">Settings</string>
+    <string name="retroarch_guide">RetroArch Guide</string>
+    <string name="cores_guide">Cores Guide</string>
+    <string name="overlay_guide">Overlay How-to Guide</string>
+    <string name="shader_pack">Shader Pack</string>
+
+</resources>

android/phoenix/res/xml/prefs.xml

@@ -0,0 +1,193 @@
+<?xml version="1.0" encoding="utf-8"?>
+<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android"
+    android:title="RetroArch Settings" >
+
+    <PreferenceScreen android:title="Path Settings">
+        <PreferenceCategory android:title="ROM paths">
+            <Preference android:title="ROM directory"
+                android:summary="Sets directory where ROM browser will first browse for ROM files.">
+                <intent
+                    android:targetClass="org.retroarch.browser.ROMDirActivity"
+                    android:targetPackage="org.retroarch" />
+            </Preference>
+        </PreferenceCategory>
+        
+        <PreferenceCategory android:title="Save files">
+            <CheckBoxPreference android:title="Enable custom directory"
+                android:summary="Enables use of custom save file folder. (.srm) save files will be saved and loaded to configured directory. If not enabled, save files will reside in ROM folder."
+                android:key="savefile_directory_enable"
+                android:defaultValue="false"/>
+            <Preference android:title="Savefile directory"
+                android:summary="Sets directory where to save and load game save files.">
+                <intent
+                    android:targetClass="org.retroarch.browser.SRMDirActivity"
+                    android:targetPackage="org.retroarch" />
+            </Preference>            
+        </PreferenceCategory>
+        <PreferenceCategory android:title="Save states">
+            <CheckBoxPreference android:title="Enable custom directory"
+                android:summary="Enables use of custom save state folder. (.state) save states will be saved and loaded to configured directory. If not enabled, save states will reside in ROM folder."
+                android:key="savestate_directory_enable"
+                android:defaultValue="false"/>
+            <Preference android:title="Save state directory"
+                android:summary="Sets directory where to save and load game save states.">
+                <intent
+                    android:targetClass="org.retroarch.browser.StateDirActivity"
+                    android:targetPackage="org.retroarch" />
+            </Preference>            
+        </PreferenceCategory>
+    </PreferenceScreen>
+    <PreferenceScreen android:title="System Settings" >
+        <PreferenceCategory android:title="General" >
+            <CheckBoxPreference
+                android:defaultValue="false"
+                android:key="savestate_auto_load"
+                android:summary="Loads an automatically created savestate at startup."
+                android:title="Auto load state" />
+            <CheckBoxPreference
+                android:defaultValue="false"
+                android:key="savestate_auto_save"
+                android:summary="Automatically saves state when exiting game."
+                android:title="Auto save state" />
+        </PreferenceCategory>
+        <PreferenceCategory android:title="Rewinding" >
+            <CheckBoxPreference
+                android:defaultValue="false"
+                android:key="rewind_enable"
+                android:summary="WARNING - very CPU intensive - will decrease ingame performance."
+                android:title="Enable" />
+        </PreferenceCategory>
+    </PreferenceScreen>
+    <PreferenceScreen android:title="Video Settings" >
+        <PreferenceCategory android:title="General" >
+            <CheckBoxPreference
+                android:defaultValue="true"
+                android:key="video_vsync"
+                android:summary="When set to enabled, prevents screen tearing."
+                android:title="VSync" />
+            <CheckBoxPreference
+                android:defaultValue="true"
+                android:key="video_sync_refreshrate_to_screen"
+                android:summary="Synchronize RetroArch's refresh rate to the screen's refresh rate (recommended - some screens have refresh rates below 59.95Hz and need this enabled to get good audio/video sync)."
+                android:title="Sync refreshrate to screen" />
+            <EditTextPreference
+                android:key="video_refresh_rate"
+                android:summary="Force a specific refresh rate to be detected. Only use if auto-detection of refresh rate reports wrong refresh rate."
+                android:title="Forced refresh rate (Hz)"
+                android:numeric="decimal" />
+            <CheckBoxPreference
+                android:defaultValue="true"
+                android:key="video_allow_rotate"
+                android:summary="Will auto-rotate the screen for vertically oriented games."
+                android:title="Auto-rotate" />
+
+            <ListPreference
+                android:entries="@array/aspect_ratios"
+                android:entryValues="@array/aspect_values"
+                android:key="video_aspect_ratio"
+                android:summary="Aspect ratio to enforce."
+                android:title="Aspect ratio" />
+        </PreferenceCategory>
+        <PreferenceCategory android:title="Shaders (1st pass)" >
+            <CheckBoxPreference
+                android:defaultValue="true"
+                android:key="video_smooth"
+                android:summary="Applies Bilinear filtering, smooths out edges (settings still apply even if no shader is selected)."
+                android:title="Bilinear filter" />
+            <CheckBoxPreference
+                android:defaultValue="false"
+                android:key="video_shader_enable"
+                android:title="Enable" />
+
+            <Preference
+                android:summary="Sets GLES2 style XML shader."
+                android:title="XML shader" >
+                <intent
+                    android:targetClass="org.retroarch.browser.ShaderActivity"
+                    android:targetPackage="org.retroarch" />
+            </Preference>
+        </PreferenceCategory>
+        <PreferenceCategory android:title="Shaders (Multi-pass)" >
+            <CheckBoxPreference
+                android:defaultValue="false"
+                android:key="video_render_to_texture"
+                android:summary="Render first pass to texture (FBO). Stretch to screen with second shader."
+                android:title="Render to texture" />
+            <CheckBoxPreference
+                android:defaultValue="false"
+                android:key="video_second_pass_shader_enable"
+                android:summary="Enable custom shader for use after rendering to FBO."
+                android:title="Enable shader #2" />
+
+            <Preference
+                android:summary="Sets shader to use for second pass."
+                android:title="XML shader (2nd pass)" >
+                <intent
+                    android:targetClass="org.retroarch.browser.Shader2Activity"
+                    android:targetPackage="org.retroarch" />
+            </Preference>
+
+            <ListPreference
+                android:entries="@array/fbo_scales"
+                android:entryValues="@array/fbo_scale_values"
+                android:key="video_fbo_scale"
+                android:summary="Scale to use when rendering to FBO."
+                android:title="FBO scale" />
+            <CheckBoxPreference
+                android:defaultValue="true"
+                android:key="video_second_pass_smooth"
+                android:summary="Use Bilinear filtering on FBO texture on second pass."
+                android:title="Second pass Bilinear Filtering" />
+        </PreferenceCategory>
+        <PreferenceCategory android:title="Fonts">
+            <CheckBoxPreference android:title="Enable on-screen fonts"
+                android:summary="Enable rendering of on-screen fonts for messages."
+                android:key="video_font_enable"
+                android:defaultValue="true"/>
+        </PreferenceCategory>
+    </PreferenceScreen>
+    <PreferenceScreen android:title="Audio Settings" >
+        <PreferenceCategory android:title="Audio" >
+            <CheckBoxPreference
+                android:defaultValue="true"
+                android:key="audio_enable"
+                android:title="Enable" />
+            <CheckBoxPreference
+                android:defaultValue="true"
+                android:key="audio_rate_control"
+                android:summary="Enable dynamic rate control (recommended)."
+                android:title="Dynamic Rate Control" />
+        </PreferenceCategory>
+    </PreferenceScreen>
+    <PreferenceScreen android:title="Input Settings" >
+        <PreferenceCategory android:title="Configuration Autodetect" >
+            <CheckBoxPreference
+                android:defaultValue="true"
+                android:key="input_autodetect_enable"
+                android:summary="This will attempt to preconfigure various gamepads and/or IME apps that you connect."
+                android:title="Enable" />
+        </PreferenceCategory>
+        <PreferenceCategory android:title="Debug input reporting" >
+            <CheckBoxPreference
+                android:defaultValue="false"
+                android:key="input_debug_enable"
+                android:summary="This will report keycodes on-screen generated by your input device(s). Useful for debugging."
+                android:title="Enable" />
+        </PreferenceCategory>
+        <PreferenceCategory android:title="Touchscreen Overlay" >
+            <CheckBoxPreference
+                android:defaultValue="true"
+                android:key="input_overlay_enable"
+                android:title="Enable" />
+
+            <Preference
+                android:summary="Sets touchscreen overlay config."
+                android:title="Input overlay" >
+                <intent
+                    android:targetClass="org.retroarch.browser.OverlayActivity"
+                    android:targetPackage="org.retroarch" />
+            </Preference>
+        </PreferenceCategory>
+    </PreferenceScreen>
+
+</PreferenceScreen>

android/phoenix/src/org/retroarch/browser/ConfigFile.java

@@ -0,0 +1,116 @@
+package org.retroarch.browser;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.FileInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.HashMap;
+import java.util.Map;
+
+public class ConfigFile {
+	private HashMap<String, String> map = new HashMap<String, String>();
+
+	public void append(File file) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(
+				new FileInputStream(file.getAbsolutePath())));
+
+		String line;
+		while ((line = br.readLine()) != null)
+			parseLine(line);
+
+		br.close();
+	}
+
+	public void open(File file) throws IOException {
+		clear();
+		append(file);
+	}
+	
+	public ConfigFile(File file) throws IOException {
+		open(file);
+	}
+	
+	public ConfigFile() {}
+
+	private void parseLine(String line) {
+		String[] tokens = line.split("=", 2);
+		if (tokens.length < 2)
+			return;
+
+		for (int i = 0; i < tokens.length; i++)
+			tokens[i] = tokens[i].trim();
+
+		String key = tokens[0];
+		String value = tokens[1];
+
+		if (value.startsWith("\""))
+			value = value.substring(1, value.lastIndexOf('\"'));
+		else
+			value = value.split(" ")[0];
+
+		if (value.length() > 0)
+			map.put(key, value);
+	}
+
+	public void clear() {
+		map.clear();
+	}
+
+	public void write(File file) throws IOException {
+		PrintWriter writer = new PrintWriter(file.getAbsolutePath());
+		for (Map.Entry<String, String> entry : map.entrySet())
+			writer.println(entry.getKey() + " = \"" + entry.getValue() + "\"");
+		writer.close();
+	}
+
+	public void setString(String key, String value) {
+		map.put(key, value);
+	}
+
+	public void setBoolean(String key, boolean value) {
+		map.put(key, Boolean.toString(value));
+	}
+
+	public void setInt(String key, int value) {
+		map.put(key, Integer.toString(value));
+	}
+
+	public void setDouble(String key, double value) {
+		map.put(key, Double.toString(value));
+	}
+
+	public boolean keyExists(String key) {
+		return map.containsKey(key);
+	}
+
+	public String getString(String key) {
+		Object ret = map.get(key);
+		if (ret != null)
+			return (String) ret;
+		else
+			return null;
+	}
+
+	public int getInt(String key) throws NumberFormatException {
+		String str = getString(key);
+		if (str != null)
+			return Integer.parseInt(str);
+		else
+			throw new NumberFormatException();
+	}
+
+	public double getDouble(String key) throws NumberFormatException {
+		String str = getString(key);
+		if (str != null)
+			return Double.parseDouble(str);
+		else
+			throw new NumberFormatException();
+	}
+
+	public boolean getBoolean(String key) {
+		String str = getString(key);
+		return Boolean.parseBoolean(str);
+	}
+}

android/phoenix/src/org/retroarch/browser/DirectoryActivity.java

@@ -0,0 +1,308 @@
+package org.retroarch.browser;
+
+import org.retroarch.R;
+
+import java.util.*;
+import java.io.*;
+
+import android.content.*;
+import android.app.*;
+import android.os.*;
+import android.preference.PreferenceManager;
+import android.widget.*;
+import android.view.*;
+import android.graphics.drawable.*;
+
+class FileWrapper implements IconAdapterItem {
+	public final File file;
+	public final boolean parentItem;
+	public final boolean dirSelectItem;
+	
+	protected final boolean enabled;
+	
+	public static final int DIRSELECT = 0;
+	public static final int PARENT = 1;
+	public static final int FILE = 2;
+	
+	protected final int typeIndex;
+
+	public FileWrapper(File aFile, int type, boolean aIsEnabled) {
+		file = aFile;
+		
+		parentItem = type == PARENT;
+		dirSelectItem = type == DIRSELECT;		
+		typeIndex = type == FILE ? (FILE + (file.isDirectory() ? 0 : 1)) : type;	
+		
+		enabled = parentItem || dirSelectItem || aIsEnabled;
+	}
+
+	@Override
+	public boolean isEnabled() {
+		return enabled;
+	}
+
+	@Override
+	public String getText() {
+		if (dirSelectItem)
+			return "[[Use this directory]]";
+		else if (parentItem)
+			return "[Parent Directory]";
+		else
+			return file.getName();
+	}
+
+	@Override
+	public int getIconResourceId() {
+		if (!parentItem && !dirSelectItem) {
+			return file.isFile() ? R.drawable.ic_file : R.drawable.ic_dir;
+		} else {
+			return R.drawable.ic_dir;
+		}
+	}
+
+	@Override
+	public Drawable getIconDrawable() {
+		return null;
+	}
+
+	public int compareTo(FileWrapper aOther) {
+		if (aOther != null) {
+			// Who says ternary is hard to follow
+			if (isEnabled() == aOther.isEnabled()) {
+				return (typeIndex == aOther.typeIndex) ? file
+						.compareTo(aOther.file)
+						: ((typeIndex < aOther.typeIndex) ? -1 : 1);
+			} else {
+				return isEnabled() ? -1 : 1;
+			}
+		}
+
+		return -1;
+	}
+}
+
+public class DirectoryActivity extends Activity implements
+		AdapterView.OnItemClickListener {
+	private IconAdapter<FileWrapper> adapter;
+	private File listedDirectory;
+
+	public static class BackStackItem implements Parcelable {
+		public String path;
+		public boolean parentIsBack;
+
+		public BackStackItem(String aPath, boolean aParentIsBack) {
+			path = aPath;
+			parentIsBack = aParentIsBack;
+		}
+
+		private BackStackItem(Parcel aIn) {
+			path = aIn.readString();
+			parentIsBack = aIn.readInt() != 0;
+		}
+
+		public int describeContents() {
+			return 0;
+		}
+
+		public void writeToParcel(Parcel out, int flags) {
+			out.writeString(path);
+			out.writeInt(parentIsBack ? 1 : 0);
+		}
+
+		public static final Parcelable.Creator<BackStackItem> CREATOR = new Parcelable.Creator<BackStackItem>() {
+			public BackStackItem createFromParcel(Parcel in) {
+				return new BackStackItem(in);
+			}
+
+			public BackStackItem[] newArray(int size) {
+				return new BackStackItem[size];
+			}
+		};
+
+	}
+
+	private ArrayList<BackStackItem> backStack;
+	
+	protected String startDirectory;
+	protected String pathSettingKey;
+	
+	protected void setStartDirectory(String path) {
+		startDirectory = path;
+	}
+	
+	protected void setPathSettingKey(String key) {
+		pathSettingKey = key;
+	}
+	
+	private boolean isDirectoryTarget;
+	protected void setIsDirectoryTarget(boolean enable) {
+		isDirectoryTarget = enable;
+	}
+
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+		setContentView(R.layout.line_list);
+
+		// Setup the list
+		adapter = new IconAdapter<FileWrapper>(this, R.layout.line_list_item);
+		ListView list = (ListView) findViewById(R.id.list);
+		list.setAdapter(adapter);
+		list.setOnItemClickListener(this);
+
+		// Load Directory
+		if (savedInstanceState != null) {
+			backStack = savedInstanceState.getParcelableArrayList("BACKSTACK");
+		}
+
+		if (backStack == null || backStack.size() == 0) {
+			backStack = new ArrayList<BackStackItem>();
+			String startPath = (startDirectory == null || startDirectory.isEmpty()) ? Environment
+					.getExternalStorageDirectory().getPath() : startDirectory;
+			backStack.add(new BackStackItem(startPath, false));
+		}
+
+		wrapFiles();
+	}
+
+	@Override
+	protected void onSaveInstanceState(Bundle aState) {
+		super.onSaveInstanceState(aState);
+		aState.putParcelableArrayList("BACKSTACK", backStack);
+	}
+	
+	private void finishWithPath(String path) {
+		if (pathSettingKey != null && !pathSettingKey.isEmpty()) {
+			SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(getBaseContext());
+			SharedPreferences.Editor editor = settings.edit();
+			editor.putString(pathSettingKey, path);
+			editor.commit();
+		}
+		
+		Intent intent = new Intent();			
+		intent.putExtra("PATH", path);
+		setResult(RESULT_OK, intent);
+		finish();
+	}
+
+	@Override
+	public void onItemClick(AdapterView<?> aListView, View aView,
+			int aPosition, long aID) {
+		final FileWrapper item = adapter.getItem(aPosition);
+
+		if (item.parentItem && backStack.get(backStack.size() - 1).parentIsBack) {
+			backStack.remove(backStack.size() - 1);
+			wrapFiles();
+			return;
+		} else if (item.dirSelectItem) {
+			finishWithPath(listedDirectory.getAbsolutePath());
+			return;
+		}
+
+		final File selected = item.parentItem ? listedDirectory.getParentFile()
+				: item.file;
+
+		if (selected.isDirectory()) {
+			backStack.add(new BackStackItem(selected.getAbsolutePath(),
+					!item.parentItem));
+			wrapFiles();
+		} else {
+			String filePath = selected.getAbsolutePath();
+			finishWithPath(filePath);
+		}
+	}
+
+	@Override
+	public boolean onKeyDown(int keyCode, KeyEvent event) {
+		if (keyCode == KeyEvent.KEYCODE_BACK) {
+			if (backStack.size() > 1) {
+				backStack.remove(backStack.size() - 1);
+				wrapFiles();
+			} else {
+				Intent intent = new Intent();
+				setResult(RESULT_CANCELED, intent);
+				finish();
+			}
+			return true;
+		}
+
+		return super.onKeyDown(keyCode, event);
+	}
+	
+	private ArrayList<String> allowedExt;
+	private ArrayList<String> disallowedExt;
+	
+	private boolean filterPath(String path) {
+		if (disallowedExt != null) {
+			for (String ext : disallowedExt)
+				if (path.endsWith(ext))
+					return false;
+		}
+		
+		if (allowedExt != null) {
+			for (String ext : allowedExt)
+				if (path.endsWith(ext))
+					return true;
+			
+			return false;
+		}
+
+		return true;
+	}
+	
+	protected void addAllowedExt(String ext) {
+		if (allowedExt == null)
+			allowedExt = new ArrayList<String>();
+		
+		allowedExt.add(ext);
+	}
+	
+	protected void addDisallowedExt(String ext) {
+		if (disallowedExt == null)
+			disallowedExt = new ArrayList<String>();
+		
+		disallowedExt.add(ext);
+	}
+
+	private void wrapFiles() {
+		listedDirectory = new File(backStack.get(backStack.size() - 1).path);
+
+		if (!listedDirectory.isDirectory()) {
+			throw new IllegalArgumentException("Directory is not valid.");
+		}
+
+		adapter.clear();
+		setTitle(listedDirectory.getAbsolutePath());
+		
+		if (isDirectoryTarget)
+			adapter.add(new FileWrapper(null, FileWrapper.DIRSELECT, true));
+
+		if (listedDirectory.getParentFile() != null)
+			adapter.add(new FileWrapper(null, FileWrapper.PARENT, true));
+
+		// Copy new items
+		final File[] files = listedDirectory.listFiles();
+		if (files != null) {
+			for (File file : files) {
+				String path = file.getName();
+
+				boolean allowFile = file.isDirectory() || (filterPath(path) && !isDirectoryTarget);
+
+				if (allowFile)
+					adapter.add(new FileWrapper(file, FileWrapper.FILE,
+							file.isDirectory() || true));
+			}
+		}
+
+		// Sort items
+		adapter.sort(new Comparator<FileWrapper>() {
+			@Override
+			public int compare(FileWrapper aLeft, FileWrapper aRight) {
+				return aLeft.compareTo(aRight);
+			};
+		});
+
+		// Update
+		adapter.notifyDataSetChanged();
+	}
+}

android/phoenix/src/org/retroarch/browser/IconAdapter.java

@@ -0,0 +1,71 @@
+package org.retroarch.browser;
+
+import org.retroarch.R;
+
+import android.app.*;
+import android.content.*;
+import android.graphics.drawable.*;
+import android.view.*;
+import android.widget.*;
+
+interface IconAdapterItem {
+	public abstract boolean isEnabled();
+
+	public abstract String getText();
+
+	public abstract int getIconResourceId();
+
+	public abstract Drawable getIconDrawable();
+}
+
+class IconAdapter<T extends IconAdapterItem> extends ArrayAdapter<T> {
+	private final int layout;
+
+	public IconAdapter(Activity aContext, int aLayout) {
+		super(aContext, aLayout);
+
+		layout = aLayout;
+	}
+
+	@Override
+	public View getView(int aPosition, View aConvertView, ViewGroup aParent) {
+		// Build the view
+		if (aConvertView == null) {
+			LayoutInflater inflater = (LayoutInflater) aParent.getContext()
+					.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+			aConvertView = inflater.inflate(layout, aParent, false);
+		}
+
+		// Fill the view
+		IconAdapterItem item = getItem(aPosition);
+		final boolean enabled = item.isEnabled();
+
+		TextView textView = (TextView) aConvertView.findViewById(R.id.name);
+		if (null != textView) {
+			textView.setText(item.getText());
+			textView.setEnabled(enabled);
+		}
+
+		ImageView imageView = (ImageView) aConvertView.findViewById(R.id.icon);
+		if (null != imageView) {
+			if (enabled) {
+				final int id = item.getIconResourceId();
+				if (0 != id) {
+					imageView.setImageResource(id);
+				} else {
+					imageView.setImageDrawable(item.getIconDrawable());
+				}
+			} else {
+				imageView.setImageDrawable(null);
+			}
+		}
+
+		return aConvertView;
+	}
+
+	@Override
+	public boolean isEnabled(int aPosition) {
+		return getItem(aPosition).isEnabled();
+	}
+
+}

android/phoenix/src/org/retroarch/browser/OverlayActivity.java

@@ -0,0 +1,18 @@
+package org.retroarch.browser;
+
+import java.io.File;
+
+import android.os.Bundle;
+
+public class OverlayActivity extends DirectoryActivity {
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		File overlayDir = new File(getCacheDir(), "Overlays");
+		if (overlayDir.exists())
+			super.setStartDirectory(overlayDir.getAbsolutePath());
+		
+		super.addAllowedExt(".cfg");
+		super.setPathSettingKey("input_overlay");
+		super.onCreate(savedInstanceState);
+	}
+}

android/phoenix/src/org/retroarch/browser/ROMActivity.java

@@ -0,0 +1,24 @@
+package org.retroarch.browser;
+
+import java.io.File;
+
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+
+public class ROMActivity extends DirectoryActivity {
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		
+		SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(getBaseContext());
+		String startPath = prefs.getString("phoenix_rom_dir", "");
+		if (!startPath.isEmpty() && new File(startPath).exists())
+			super.setStartDirectory(startPath);
+
+		super.addDisallowedExt(".state");
+		super.addDisallowedExt(".srm");
+		super.addDisallowedExt(".state.auto");
+		super.addDisallowedExt(".rtc");
+		super.onCreate(savedInstanceState);
+	}
+}

android/phoenix/src/org/retroarch/browser/ROMDirActivity.java

@@ -0,0 +1,12 @@
+package org.retroarch.browser;
+
+import android.os.Bundle;
+
+public class ROMDirActivity extends DirectoryActivity {
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		super.setPathSettingKey("phoenix_rom_dir");
+		super.setIsDirectoryTarget(true);
+		super.onCreate(savedInstanceState);
+	}
+}

android/phoenix/src/org/retroarch/browser/RetroArch.java

@@ -0,0 +1,425 @@
+package org.retroarch.browser;
+
+import org.retroarch.R;
+
+import java.io.*;
+
+import android.content.*;
+import android.content.res.AssetManager;
+import android.app.*;
+import android.net.Uri;
+import android.os.*;
+import android.preference.PreferenceManager;
+import android.provider.Settings;
+import android.widget.*;
+import android.util.Log;
+import android.view.*;
+import android.view.inputmethod.*;
+import android.graphics.drawable.*;
+
+class ModuleWrapper implements IconAdapterItem {
+	public final File file;
+
+	public ModuleWrapper(Context aContext, File aFile) throws IOException {
+		file = aFile;
+	}
+
+	@Override
+	public boolean isEnabled() {
+		return true;
+	}
+
+	@Override
+	public String getText() {
+		return file.getName();
+	}
+
+	@Override
+	public int getIconResourceId() {
+		return 0;
+	}
+
+	@Override
+	public Drawable getIconDrawable() {
+		return null;
+	}
+}
+
+public class RetroArch extends Activity implements
+		AdapterView.OnItemClickListener, PopupMenu.OnMenuItemClickListener {
+	private IconAdapter<ModuleWrapper> adapter;
+	static private final int ACTIVITY_LOAD_ROM = 0;
+	static private String libretro_path;
+	static private final String TAG = "RetroArch-Phoenix";
+	private ConfigFile config;
+	
+	private final double getDisplayRefreshRate() {
+		final WindowManager wm = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
+		final Display display = wm.getDefaultDisplay();
+		return display.getRefreshRate();
+	}
+
+	private final double getRefreshRate() {
+		double rate = 0;
+		SharedPreferences prefs = PreferenceManager
+				.getDefaultSharedPreferences(getBaseContext());
+		String refresh_rate = prefs.getString("video_refresh_rate", "");
+		if (!refresh_rate.isEmpty()) {
+			try {
+				rate = Double.parseDouble(refresh_rate);
+			} catch (NumberFormatException e) {
+				Log.e(TAG, "Cannot parse: " + refresh_rate + " as a double!");
+				rate = getDisplayRefreshRate();
+			}
+		} else {
+			rate = getDisplayRefreshRate();
+		}
+		
+		Log.i(TAG, "Using refresh rate: " + rate + " Hz.");
+		return rate;
+	}
+	
+	private String readCPUInfo() {
+		String result = "";
+
+		try {
+			BufferedReader br = new BufferedReader(new InputStreamReader(
+					new FileInputStream("/proc/cpuinfo")));
+
+			String line;
+			while ((line = br.readLine()) != null)
+				result += line + "\n";
+			br.close();
+		} catch (IOException ex) {
+			ex.printStackTrace();
+		}
+		return result;
+	}
+	
+	private boolean cpuInfoIsNeon(String info) {
+		return info.contains("neon");
+	}
+
+	private byte[] loadAsset(String asset) throws IOException {
+		String path = asset;
+		InputStream stream = getAssets().open(path);
+		int len = stream.available();
+		byte[] buf = new byte[len];
+		stream.read(buf, 0, len);
+		return buf;
+	}
+	
+	private void extractAssets(AssetManager manager, String cacheDir, String relativePath, int level) throws IOException {
+		final String[] paths = manager.list(relativePath);
+		if (paths != null && paths.length > 0) { // Directory
+			Log.d(TAG, "Extracting assets directory: " + relativePath);
+			for (final String path : paths)
+				extractAssets(manager, cacheDir, relativePath + (level > 0 ? File.separator : "") + path, level + 1);	
+		} else { // File, extract.
+			Log.d(TAG, "Extracting assets file: " + relativePath);
+			
+			String parentPath = new File(relativePath).getParent();
+			if (parentPath != null) {
+				File parentFile = new File(cacheDir, parentPath);
+				Log.d(TAG, "Creating folder: " + parentFile.getAbsolutePath());
+				parentFile.mkdirs(); // Doesn't throw.
+			}
+			
+			byte[] asset = loadAsset(relativePath);
+			BufferedOutputStream writer = new BufferedOutputStream(
+					new FileOutputStream(new File(cacheDir, relativePath)));
+
+			writer.write(asset, 0, asset.length);
+			writer.flush();
+			writer.close();
+		}
+	}
+	
+	private void extractAssets() {
+		try {
+			AssetManager assets = getAssets();
+			String cacheDir = getCacheDir().getAbsolutePath();
+			//extractAssets(assets, cacheDir, "", 0);
+			//extractAssets(assets, cacheDir, "Shaders", 1);
+			extractAssets(assets, cacheDir, "Overlays", 1);
+		} catch (IOException e) {
+			Log.e(TAG, "Failed to extract assets to cache.");			
+		}
+	}
+
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		try {
+			config = new ConfigFile(new File(getDefaultConfigPath()));
+		} catch (IOException e) {
+			config = new ConfigFile();
+		}
+		
+		String cpuInfo = readCPUInfo();
+		boolean cpuIsNeon = cpuInfoIsNeon(cpuInfo);
+		
+		// Extracting assets appears to take considerable amount of time, so
+		// move extraction to a thread.
+		Thread assetThread = new Thread(new Runnable() {
+			public void run() {
+				extractAssets();
+			}
+		});
+		assetThread.start();
+		
+		setContentView(R.layout.line_list);
+
+		// Setup the list
+		adapter = new IconAdapter<ModuleWrapper>(this, R.layout.line_list_item);
+		ListView list = (ListView) findViewById(R.id.list);
+		list.setAdapter(adapter);
+		list.setOnItemClickListener(this);
+
+		setTitle("Select Libretro core");
+
+		// Populate the list
+		final String modulePath = getApplicationInfo().nativeLibraryDir;
+		final File[] libs = new File(modulePath).listFiles();
+		for (final File lib : libs) {
+			String libName = lib.getName();
+			
+			// Never append a NEON lib if we don't have NEON.
+			if (libName.contains("neon") && !cpuIsNeon)
+				continue;
+			
+			// If we have a NEON version with NEON capable CPU,
+			// never append a non-NEON version.
+			if (cpuIsNeon && !libName.contains("neon")) {
+				boolean hasNeonVersion = false;
+				for (final File lib_ : libs) {
+					String otherName = lib_.getName();
+					String baseName = libName.replace(".so", "");
+					if (otherName.contains("neon") && otherName.startsWith(baseName)) {
+						hasNeonVersion = true;
+						break;
+					}
+				}
+				
+				if (hasNeonVersion)
+					continue;
+			}
+			
+			// Allow both libretro-core.so and libretro_core.so.
+			if (libName.startsWith("libretro") && !libName.startsWith("libretroarch")) {
+				try {
+					adapter.add(new ModuleWrapper(this, lib));
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+		}
+	}
+
+	@Override
+	public void onItemClick(AdapterView<?> aListView, View aView,
+			int aPosition, long aID) {
+		final ModuleWrapper item = adapter.getItem(aPosition);
+		libretro_path = item.file.getAbsolutePath();
+
+		Intent myIntent;
+		myIntent = new Intent(this, ROMActivity.class);
+		startActivityForResult(myIntent, ACTIVITY_LOAD_ROM);
+	}
+	
+	private String getDefaultConfigPath() {
+		String internal = System.getenv("INTERNAL_STORAGE");
+		String external = System.getenv("EXTERNAL_STORAGE");
+		
+		if (external != null) {
+			String confPath = external + File.separator + "retroarch.cfg";
+			if (new File(confPath).exists())
+				return confPath;
+		} else if (internal != null) {
+			String confPath = internal + File.separator + "retroarch.cfg";
+			if (new File(confPath).exists())
+				return confPath;
+		} else {
+			String confPath = "/mnt/extsd/retroarch.cfg";
+			if (new File(confPath).exists())
+				return confPath;
+		}
+		
+		if (internal != null && new File(internal + File.separator + "retroarch.cfg").canWrite())
+			return internal + File.separator + "retroarch.cfg";
+		else if (external != null && new File(internal + File.separator + "retroarch.cfg").canWrite())
+			return external + File.separator + "retroarch.cfg";
+		else
+			return getCacheDir().getAbsolutePath() + File.separator + "retroarch.cfg";
+	}
+	
+	private void updateConfigFile() {
+		SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(getBaseContext());
+		config.setBoolean("audio_rate_control", prefs.getBoolean("audio_rate_control", true));
+		config.setBoolean("audio_enable", prefs.getBoolean("audio_enable", true));
+		config.setBoolean("video_smooth", prefs.getBoolean("video_smooth", true));
+		config.setBoolean("video_allow_rotate", prefs.getBoolean("video_allow_rotate", true));
+		config.setBoolean("savestate_auto_load", prefs.getBoolean("savestate_auto_load", false));
+		config.setBoolean("savestate_auto_save", prefs.getBoolean("savestate_auto_save", false));
+		config.setBoolean("rewind_enable", prefs.getBoolean("rewind_enable", false));
+		config.setBoolean("video_vsync", prefs.getBoolean("video_vsync", true));
+		config.setBoolean("input_autodetect_enable", prefs.getBoolean("input_autodetect_enable", true));
+		config.setBoolean("input_debug_enable", prefs.getBoolean("input_debug_enable", false));
+		
+		if (prefs.getBoolean("video_sync_refreshrate_to_screen", true)
+				&& (getRefreshRate() < 59.95)) {
+			Log.i(TAG,
+					"Refresh rate of screen lower than 59.95Hz, adjusting to screen.");
+			config.setDouble("video_refresh_rate", getRefreshRate());
+		} else {
+			Log.i(TAG, "Refresh rate set to 59.95Hz (default).");
+			config.setDouble("video_refresh_rate", 59.95);
+		}
+		
+		String aspect = prefs.getString("video_aspect_ratio", "auto");
+		if (aspect.equals("full")) {
+			config.setBoolean("video_force_aspect", false);
+		} else if (aspect.equals("auto")) {
+			config.setBoolean("video_force_aspect", true);
+			config.setBoolean("video_force_aspect_auto", true);
+			config.setDouble("video_aspect_ratio", -1.0);
+		} else if (aspect.equals("square")) {
+			config.setBoolean("video_force_aspect", true);
+			config.setBoolean("video_force_aspect_auto", false);
+			config.setDouble("video_aspect_ratio", -1.0);
+		} else {
+			double aspect_ratio = Double.parseDouble(aspect);
+			config.setBoolean("video_force_aspect", true);
+			config.setDouble("video_aspect_ratio", aspect_ratio);
+		}
+		
+		String shaderPath = prefs.getString("video_bsnes_shader", "");
+		if (prefs.getBoolean("video_shader_enable", false) && new File(shaderPath).exists()) {
+			config.setString("video_shader_type", "bsnes");
+			config.setString("video_bsnes_shader", shaderPath);
+		} else {
+			config.setString("video_shader_type", "none");
+			config.setString("video_bsnes_shader", "");
+		}
+		
+		config.setBoolean("video_render_to_texture", prefs.getBoolean("video_render_to_texture", false));
+		config.setString("video_second_pass_shader",
+				prefs.getBoolean("video_second_pass_shader_enable", false) ?
+						prefs.getString("video_second_pass_shader", "") : "");
+		
+		config.setBoolean("video_second_pass_smooth", prefs.getBoolean("video_second_pass_smooth", true));
+		
+		config.setString("video_fbo_scale_x", prefs.getString("video_fbo_scale", "2.0"));
+		config.setString("video_fbo_scale_y", prefs.getString("video_fbo_scale", "2.0"));
+		
+		boolean useOverlay = prefs.getBoolean("input_overlay_enable", true);
+		if (useOverlay) {
+			String overlayPath = prefs.getString("input_overlay", getCacheDir() + "/Overlays/basic_overlay.cfg");
+			config.setString("input_overlay", overlayPath);
+		} else {
+			config.setString("input_overlay", "");
+		}
+		
+		config.setString("savefile_directory", prefs.getBoolean("savefile_directory_enable", false) ?
+				prefs.getString("savefile_directory", "") : "");
+		config.setString("savestate_directory", prefs.getBoolean("savestate_directory_enable", false) ?
+				prefs.getString("savestate_directory", "") : "");
+		
+		config.setBoolean("video_font_enable", prefs.getBoolean("video_font_enable", true));
+
+		String confPath = getDefaultConfigPath();
+		try {
+			config.write(new File(confPath));
+		} catch (IOException e) {
+			Log.e(TAG, "Failed to save config file to: " + confPath);
+		}
+	}
+
+	protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+		Intent myIntent;
+		String current_ime = Settings.Secure.getString(getContentResolver(), Settings.Secure.DEFAULT_INPUT_METHOD);
+		
+		updateConfigFile();
+		
+		switch (requestCode) {
+		case ACTIVITY_LOAD_ROM:
+			if (data.getStringExtra("PATH") != null) {
+				Toast.makeText(this,
+						"Loading: [" + data.getStringExtra("PATH") + "]...",
+						Toast.LENGTH_SHORT).show();
+				myIntent = new Intent(this, NativeActivity.class);
+				myIntent.putExtra("ROM", data.getStringExtra("PATH"));
+				myIntent.putExtra("LIBRETRO", libretro_path);
+				myIntent.putExtra("CONFIGFILE", getDefaultConfigPath());
+				myIntent.putExtra("IME", current_ime);
+				startActivity(myIntent);
+			}
+			break;
+		}
+	}
+
+	@Override
+	public boolean onCreateOptionsMenu(Menu aMenu) {
+		super.onCreateOptionsMenu(aMenu);
+		getMenuInflater().inflate(R.menu.directory_list, aMenu);
+		return true;
+	}
+	
+	public void showPopup(View v) {
+		PopupMenu menu = new PopupMenu(this, v);
+		MenuInflater inflater = menu.getMenuInflater();
+		inflater.inflate(R.menu.context_menu, menu.getMenu());
+		menu.setOnMenuItemClickListener(this);
+		menu.show();
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(MenuItem aItem) {
+		switch (aItem.getItemId()) {
+		case R.id.settings:
+			showPopup(findViewById(R.id.settings));
+			Log.i(TAG, "Got settings ...");
+			return true;
+
+		default:
+			return super.onOptionsItemSelected(aItem);
+		}
+	}
+
+	@Override
+	public boolean onMenuItemClick(MenuItem item) {
+		switch (item.getItemId()) {
+		case R.id.input_method_select:
+			InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
+			imm.showInputMethodPicker();
+			return true;
+			
+		case R.id.rarch_settings:
+			Log.i(TAG, "Rarch settings clicked!");			
+			Intent rset = new Intent(this, SettingsActivity.class);
+			startActivity(rset);
+			return true;
+
+		case R.id.retroarch_guide:
+			Intent rguide = new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.libretro.org/documents/retroarch-manual.pdf"));
+			startActivity(rguide);
+			return true;
+
+		case R.id.cores_guide:
+			Intent cguide = new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.libretro.org/documents/retroarch-cores-manual.pdf"));
+			startActivity(cguide);
+			return true;
+		case R.id.overlay_guide:
+			Intent mguide = new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.libretro.org/documents/overlay.pdf"));
+			startActivity(mguide);
+			return true;
+		case R.id.shader_pack:
+			Intent sguide = new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.libretro.org/shaders/xml-gles-shaders.zip"));
+			startActivity(sguide);
+			return true;
+		default:
+			return false;
+		}
+	}
+}

android/phoenix/src/org/retroarch/browser/SRMDirActivity.java

@@ -0,0 +1,12 @@
+package org.retroarch.browser;
+
+import android.os.Bundle;
+
+public class SRMDirActivity extends DirectoryActivity {
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		super.setPathSettingKey("savefile_directory");
+		super.setIsDirectoryTarget(true);
+		super.onCreate(savedInstanceState);
+	}
+}

android/phoenix/src/org/retroarch/browser/SettingsActivity.java

@@ -0,0 +1,29 @@
+package org.retroarch.browser;
+
+import org.retroarch.R;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.preference.PreferenceFragment;
+import android.preference.PreferenceManager;
+
+public class SettingsActivity extends Activity {
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+		getFragmentManager().beginTransaction().
+			replace(android.R.id.content, new SettingsFragment()).commit();
+		PreferenceManager.setDefaultValues(this, R.xml.prefs, false);
+	}
+	
+	public static class SettingsFragment extends PreferenceFragment {
+		
+	    @Override
+	    public void onCreate(Bundle savedInstanceState) {
+	        super.onCreate(savedInstanceState);
+
+	        // Load the preferences from an XML resource
+	        addPreferencesFromResource(R.xml.prefs);
+	    }
+	}
+}

android/phoenix/src/org/retroarch/browser/Shader2Activity.java

@@ -0,0 +1,18 @@
+package org.retroarch.browser;
+
+import java.io.File;
+
+import android.os.Bundle;
+
+public class Shader2Activity extends DirectoryActivity {
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		File shaderDir = new File(getCacheDir(), "Shaders");
+		if (shaderDir.exists())
+			super.setStartDirectory(shaderDir.getAbsolutePath());
+		
+		super.addAllowedExt(".shader");
+		super.setPathSettingKey("video_second_pass_shader");
+		super.onCreate(savedInstanceState);
+	}
+}

android/phoenix/src/org/retroarch/browser/ShaderActivity.java

@@ -0,0 +1,18 @@
+package org.retroarch.browser;
+
+import java.io.File;
+
+import android.os.Bundle;
+
+public class ShaderActivity extends DirectoryActivity {
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		File shaderDir = new File(getCacheDir(), "Shaders");
+		if (shaderDir.exists())
+			super.setStartDirectory(shaderDir.getAbsolutePath());
+		
+		super.addAllowedExt(".shader");
+		super.setPathSettingKey("video_bsnes_shader");
+		super.onCreate(savedInstanceState);
+	}
+}

android/phoenix/src/org/retroarch/browser/StateDirActivity.java

@@ -0,0 +1,12 @@
+package org.retroarch.browser;
+
+import android.os.Bundle;
+
+public class StateDirActivity extends DirectoryActivity {
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		super.setPathSettingKey("savestate_directory");
+		super.setIsDirectoryTarget(true);
+		super.onCreate(savedInstanceState);
+	}
+}

audio/alsa.c

@@ -1,27 +1,25 @@
-/*  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.
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
  * 
- *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  RetroArch 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;
+ *  RetroArch 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.
+ *  You should have received a copy of the GNU General Public License along with RetroArch.
  *  If not, see <http://www.gnu.org/licenses/>.
  */
 
 
-#include "driver.h"
+#include "../driver.h"
 #include <stdlib.h>
-#include <alsa/asoundlib.h>
-#include "general.h"
+#include <asoundlib.h>
+#include "../general.h"
 
-#define TRY_ALSA(x) if ( x < 0 ) { \
+#define TRY_ALSA(x) if (x < 0) { \
                   goto error; \
                }
 
@@ -30,11 +28,13 @@ typedef struct alsa
    snd_pcm_t *pcm;
    bool nonblock;
    bool has_float;
+
+   size_t buffer_size;
 } alsa_t;
 
-static bool __alsa_use_float(void *data)
+static bool alsa_use_float(void *data)
 {
-   alsa_t *alsa = data;
+   alsa_t *alsa = (alsa_t*)data;
    return alsa->has_float;
 }
 
@@ -42,34 +42,37 @@ static bool find_float_format(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
 {
    if (snd_pcm_hw_params_test_format(pcm, params, SND_PCM_FORMAT_FLOAT) == 0)
    {
-      SSNES_LOG("ALSA: Using floating point format.\n");
+      RARCH_LOG("ALSA: Using floating point format.\n");
       return true;
    }
-   SSNES_LOG("ALSA: Using signed 16-bit format.\n");
+   RARCH_LOG("ALSA: Using signed 16-bit format.\n");
    return false;
 }
 
-static void* __alsa_init(const char* device, int rate, int latency)
+static void *alsa_init(const char *device, unsigned rate, unsigned latency)
 {
-   alsa_t *alsa = calloc(1, sizeof(alsa_t));
-   if ( alsa == NULL )
+   alsa_t *alsa = (alsa_t*)calloc(1, sizeof(alsa_t));
+   if (!alsa)
       return NULL;
 
    snd_pcm_hw_params_t *params = NULL;
    snd_pcm_sw_params_t *sw_params = NULL;
 
    const char *alsa_dev = "default";
-   if ( device != NULL )
+   if (device)
       alsa_dev = device;
 
+   unsigned latency_usec = latency * 1000;
+   unsigned channels = 2;
+   unsigned periods = 4;
+   snd_pcm_uframes_t buffer_size;
+   snd_pcm_format_t format;
+
    TRY_ALSA(snd_pcm_open(&alsa->pcm, alsa_dev, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK));
 
-   unsigned int latency_usec = latency * 1000;
-
    TRY_ALSA(snd_pcm_hw_params_malloc(&params));
    alsa->has_float = find_float_format(alsa->pcm, params);
-   snd_pcm_format_t format = alsa->has_float ? SND_PCM_FORMAT_FLOAT : SND_PCM_FORMAT_S16;
-   unsigned int channels = 2;
+   format = alsa->has_float ? SND_PCM_FORMAT_FLOAT : SND_PCM_FORMAT_S16;
 
    TRY_ALSA(snd_pcm_hw_params_any(alsa->pcm, params));
    TRY_ALSA(snd_pcm_hw_params_set_access(alsa->pcm, params, SND_PCM_ACCESS_RW_INTERLEAVED));
@@ -78,16 +81,15 @@ static void* __alsa_init(const char* device, int rate, int latency)
    TRY_ALSA(snd_pcm_hw_params_set_rate(alsa->pcm, params, rate, 0));
 
    TRY_ALSA(snd_pcm_hw_params_set_buffer_time_near(alsa->pcm, params, &latency_usec, NULL));
-   unsigned periods = 4;
    TRY_ALSA(snd_pcm_hw_params_set_periods_near(alsa->pcm, params, &periods, NULL));
 
    TRY_ALSA(snd_pcm_hw_params(alsa->pcm, params));
 
-   snd_pcm_uframes_t buffer_size;
    snd_pcm_hw_params_get_period_size(params, &buffer_size, NULL);
-   SSNES_LOG("ALSA: Period size: %d frames\n", (int)buffer_size);
+   RARCH_LOG("ALSA: Period size: %d frames\n", (int)buffer_size);
    snd_pcm_hw_params_get_buffer_size(params, &buffer_size);
-   SSNES_LOG("ALSA: Buffer size: %d frames\n", (int)buffer_size);
+   RARCH_LOG("ALSA: Buffer size: %d frames\n", (int)buffer_size);
+   alsa->buffer_size = snd_pcm_frames_to_bytes(alsa->pcm, buffer_size);
 
    TRY_ALSA(snd_pcm_sw_params_malloc(&sw_params));
    TRY_ALSA(snd_pcm_sw_params_current(alsa->pcm, sw_params));
@@ -100,7 +102,7 @@ static void* __alsa_init(const char* device, int rate, int latency)
    return alsa;
 
 error:
-   SSNES_ERR("ALSA: Failed to initialize...\n");
+   RARCH_ERR("ALSA: Failed to initialize...\n");
    if (params)
       snd_pcm_hw_params_free(params);
 
@@ -117,70 +119,99 @@ error:
    return NULL;
 }
 
-static ssize_t __alsa_write(void* data, const void* buf, size_t size)
+static ssize_t alsa_write(void *data, const void *buf_, size_t size_)
 {
-   alsa_t *alsa = data;
+   alsa_t *alsa = (alsa_t*)data;
+   const uint8_t *buf = (const uint8_t*)buf_;
 
-   snd_pcm_sframes_t frames;
+   bool eagain_retry         = true;
    snd_pcm_sframes_t written = 0;
-   int rc;
-   size = snd_pcm_bytes_to_frames(alsa->pcm, size); // Frames to write
+   snd_pcm_sframes_t size    = snd_pcm_bytes_to_frames(alsa->pcm, size_);
 
-   while (written < size)
+   while (size)
    {
       if (!alsa->nonblock)
       {
-         rc = snd_pcm_wait(alsa->pcm, -1);
-         if (rc == -EPIPE || rc == -ESTRPIPE)
+         int rc = snd_pcm_wait(alsa->pcm, -1);
+         if (rc == -EPIPE || rc == -ESTRPIPE || rc == -EINTR)
          {
             if (snd_pcm_recover(alsa->pcm, rc, 1) < 0)
+            {
+               RARCH_ERR("[ALSA]: (#1) Failed to recover from error (%s)\n",
+                     snd_strerror(rc));
                return -1;
+            }
             continue;
          }
       }
 
-      frames = snd_pcm_writei(alsa->pcm, (const char*)buf + written * 2 * (alsa->has_float ? sizeof(float) : sizeof(int16_t)), size - written);
+      snd_pcm_sframes_t frames = snd_pcm_writei(alsa->pcm, buf, size);
 
-      if ( frames == -EPIPE || frames == -EINTR || frames == -ESTRPIPE )
+      if (frames == -EPIPE || frames == -EINTR || frames == -ESTRPIPE)
       {
-         if ( snd_pcm_recover(alsa->pcm, frames, 1) < 0 )
+         if (snd_pcm_recover(alsa->pcm, frames, 1) < 0)
+         {
+            RARCH_ERR("[ALSA]: (#2) Failed to recover from error (%s)\n",
+                  snd_strerror(frames));
             return -1;
+         }
 
-         return 0;
+         break;
       }
-      else if ( frames == -EAGAIN && alsa->nonblock )
-         return 0;
-      else if ( frames < 0 )
+      else if (frames == -EAGAIN && !alsa->nonblock) // Definitely not supposed to happen.
+      {
+         RARCH_WARN("[ALSA]: poll() was signaled, but EAGAIN returned from write.\n"
+               "Your ALSA driver might be subtly broken.\n");
+
+         if (eagain_retry)
+         {
+            eagain_retry = false;
+            continue;
+         }
+         else
+            return written;
+      }
+      else if (frames == -EAGAIN) // Expected if we're running nonblock.
+      {
+         return written;
+      }
+      else if (frames < 0)
+      {
+         RARCH_ERR("[ALSA]: Unknown error occured (%s).\n", snd_strerror(frames));
          return -1;
+      }
 
       written += frames;
+      buf     += (frames << 1) * (alsa->has_float ? sizeof(float) : sizeof(int16_t));
+      size    -= frames;
    }
 
-   return snd_pcm_frames_to_bytes(alsa->pcm, size);
+   return written;
 }
 
-static bool __alsa_stop(void *data)
+static bool alsa_stop(void *data)
 {
    return true;
 }
 
-static void __alsa_set_nonblock_state(void *data, bool state)
+static void alsa_set_nonblock_state(void *data, bool state)
 {
-   alsa_t *alsa = data;
+   alsa_t *alsa = (alsa_t*)data;
    alsa->nonblock = state;
 }
 
-static bool __alsa_start(void *data)
+static bool alsa_start(void *data)
 {
    return true;
 }
 
-static void __alsa_free(void *data)
+static void alsa_free(void *data)
 {
-   alsa_t *alsa = data;
-   if ( alsa )
+   alsa_t *alsa = (alsa_t*)data;
+
+   if (alsa)
    {
-      if ( alsa->pcm )
+      if (alsa->pcm)
       {
          snd_pcm_drop(alsa->pcm);
          snd_pcm_close(alsa->pcm);
@@ -189,19 +220,36 @@ static void __alsa_free(void *data)
    }
 }
 
+static size_t alsa_write_avail(void *data)
+{
+   alsa_t *alsa = (alsa_t*)data;
+
+   snd_pcm_sframes_t avail = snd_pcm_avail_update(alsa->pcm);
+   if (avail < 0)
+   {
+      //RARCH_WARN("[ALSA]: avail_update() failed: %s\n", snd_strerror(avail));
+      return alsa->buffer_size;
+   }
+
+   return snd_pcm_frames_to_bytes(alsa->pcm, avail);
+}
+
+static size_t alsa_buffer_size(void *data)
+{
+   alsa_t *alsa = (alsa_t*)data;
+   return alsa->buffer_size;
+}
+
 const audio_driver_t audio_alsa = {
-   .init = __alsa_init,
-   .write = __alsa_write,
-   .stop = __alsa_stop,
-   .start = __alsa_start,
-   .use_float = __alsa_use_float,
-   .set_nonblock_state = __alsa_set_nonblock_state,
-   .free = __alsa_free,
-   .ident = "alsa"
+   alsa_init,
+   alsa_write,
+   alsa_stop,
+   alsa_start,
+   alsa_set_nonblock_state,
+   alsa_free,
+   alsa_use_float,
+   "alsa",
+   alsa_write_avail,
+   alsa_buffer_size,
 };
 
-   
-
-
-   
-   

audio/alsathread.c

@@ -0,0 +1,315 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
+ *  Copyright (C) 2012-2013 - Michael Lelli
+ * 
+ *  RetroArch 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.
+ *
+ *  RetroArch 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 RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "../driver.h"
+#include <stdlib.h>
+#include <asoundlib.h>
+#include "../general.h"
+#include "../thread.h"
+#include "../fifo_buffer.h"
+
+#define TRY_ALSA(x) if (x < 0) { \
+                  goto error; \
+               }
+
+typedef struct alsa
+{
+   snd_pcm_t *pcm;
+   bool nonblock;
+   bool has_float;
+   volatile bool thread_dead;
+
+   size_t buffer_size;
+   size_t period_size;
+   snd_pcm_uframes_t period_frames;
+
+   fifo_buffer_t *buffer;
+   sthread_t *worker_thread;
+   slock_t *fifo_lock;
+   scond_t *cond;
+   slock_t *cond_lock;
+} alsa_t;
+
+static void alsa_worker_thread(void *data)
+{
+   alsa_t *alsa = (alsa_t*)data;
+
+   uint8_t *buf = (uint8_t *)calloc(1, alsa->period_size);
+   if (!buf)
+   {
+      RARCH_ERR("failed to allocate audio buffer");
+      goto end;
+   }
+
+   while (!alsa->thread_dead)
+   {
+      slock_lock(alsa->fifo_lock);
+      size_t avail = fifo_read_avail(alsa->buffer);
+      size_t fifo_size = min(alsa->period_size, avail);
+      fifo_read(alsa->buffer, buf, fifo_size);
+      scond_signal(alsa->cond);
+      slock_unlock(alsa->fifo_lock);
+
+      // If underrun, fill rest with silence.
+      memset(buf + fifo_size, 0, alsa->period_size - fifo_size);
+
+      snd_pcm_sframes_t frames = snd_pcm_writei(alsa->pcm, buf, alsa->period_frames);
+
+      if (frames == -EPIPE || frames == -EINTR || frames == -ESTRPIPE)
+      {
+         if (snd_pcm_recover(alsa->pcm, frames, 1) < 0)
+         {
+            RARCH_ERR("[ALSA]: (#2) Failed to recover from error (%s)\n",
+                  snd_strerror(frames));
+            break;
+         }
+
+         continue;
+      }
+      else if (frames < 0)
+      {
+         RARCH_ERR("[ALSA]: Unknown error occured (%s).\n", snd_strerror(frames));
+         break;
+      }
+   }
+
+end:
+   slock_lock(alsa->cond_lock);
+   alsa->thread_dead = true;
+   scond_signal(alsa->cond);
+   slock_unlock(alsa->cond_lock);
+   free(buf);
+}
+
+static bool alsa_use_float(void *data)
+{
+   alsa_t *alsa = (alsa_t*)data;
+   return alsa->has_float;
+}
+
+static bool find_float_format(snd_pcm_t *pcm, snd_pcm_hw_params_t *params)
+{
+   if (snd_pcm_hw_params_test_format(pcm, params, SND_PCM_FORMAT_FLOAT) == 0)
+   {
+      RARCH_LOG("ALSA: Using floating point format.\n");
+      return true;
+   }
+   RARCH_LOG("ALSA: Using signed 16-bit format.\n");
+   return false;
+}
+
+static void alsa_free(void *data)
+{
+   alsa_t *alsa = (alsa_t*)data;
+
+   if (alsa)
+   {
+      if (alsa->worker_thread)
+      {
+         alsa->thread_dead = true;
+         sthread_join(alsa->worker_thread);
+      }
+      if (alsa->buffer)
+         fifo_free(alsa->buffer);
+      if (alsa->cond)
+         scond_free(alsa->cond);
+      if (alsa->fifo_lock)
+         slock_free(alsa->fifo_lock);
+      if (alsa->cond_lock)
+         slock_free(alsa->cond_lock);
+      if (alsa->pcm)
+      {
+         snd_pcm_drop(alsa->pcm);
+         snd_pcm_close(alsa->pcm);
+      }
+      free(alsa);
+   }
+}
+
+static void *alsa_init(const char *device, unsigned rate, unsigned latency)
+{
+   alsa_t *alsa = (alsa_t*)calloc(1, sizeof(alsa_t));
+   if (!alsa)
+      return NULL;
+
+   snd_pcm_hw_params_t *params = NULL;
+   snd_pcm_sw_params_t *sw_params = NULL;
+
+   const char *alsa_dev = "default";
+   if (device)
+      alsa_dev = device;
+
+   unsigned latency_usec = latency * 1000 / 2;
+
+   unsigned channels = 2;
+   unsigned periods = 4;
+   snd_pcm_uframes_t buffer_size;
+   snd_pcm_format_t format;
+
+   TRY_ALSA(snd_pcm_open(&alsa->pcm, alsa_dev, SND_PCM_STREAM_PLAYBACK, 0));
+
+   TRY_ALSA(snd_pcm_hw_params_malloc(&params));
+   alsa->has_float = find_float_format(alsa->pcm, params);
+   format = alsa->has_float ? SND_PCM_FORMAT_FLOAT : SND_PCM_FORMAT_S16;
+
+   TRY_ALSA(snd_pcm_hw_params_any(alsa->pcm, params));
+   TRY_ALSA(snd_pcm_hw_params_set_access(alsa->pcm, params, SND_PCM_ACCESS_RW_INTERLEAVED));
+   TRY_ALSA(snd_pcm_hw_params_set_format(alsa->pcm, params, format));
+   TRY_ALSA(snd_pcm_hw_params_set_channels(alsa->pcm, params, channels));
+   TRY_ALSA(snd_pcm_hw_params_set_rate(alsa->pcm, params, rate, 0));
+
+   TRY_ALSA(snd_pcm_hw_params_set_buffer_time_near(alsa->pcm, params, &latency_usec, NULL));
+   TRY_ALSA(snd_pcm_hw_params_set_periods_near(alsa->pcm, params, &periods, NULL));
+
+   TRY_ALSA(snd_pcm_hw_params(alsa->pcm, params));
+
+   snd_pcm_hw_params_get_period_size(params, &alsa->period_frames, NULL);
+   RARCH_LOG("ALSA: Period size: %d frames\n", (int)alsa->period_frames);
+   snd_pcm_hw_params_get_buffer_size(params, &buffer_size);
+   RARCH_LOG("ALSA: Buffer size: %d frames\n", (int)buffer_size);
+   alsa->buffer_size = snd_pcm_frames_to_bytes(alsa->pcm, buffer_size);
+   alsa->period_size = snd_pcm_frames_to_bytes(alsa->pcm, alsa->period_frames);
+
+   TRY_ALSA(snd_pcm_sw_params_malloc(&sw_params));
+   TRY_ALSA(snd_pcm_sw_params_current(alsa->pcm, sw_params));
+   TRY_ALSA(snd_pcm_sw_params_set_start_threshold(alsa->pcm, sw_params, buffer_size / 2));
+   TRY_ALSA(snd_pcm_sw_params(alsa->pcm, sw_params));
+
+   snd_pcm_hw_params_free(params);
+   snd_pcm_sw_params_free(sw_params);
+
+   alsa->fifo_lock = slock_new();
+   alsa->cond_lock = slock_new();
+   alsa->cond = scond_new();
+   alsa->buffer = fifo_new(alsa->buffer_size);
+   if (!alsa->fifo_lock || !alsa->cond_lock || !alsa->cond || !alsa->buffer)
+      goto error;
+
+   alsa->worker_thread = sthread_create(alsa_worker_thread, alsa);
+   if (!alsa->worker_thread)
+   {
+      RARCH_ERR("error initializing worker thread");
+      goto error;
+   }
+
+   return alsa;
+
+error:
+   RARCH_ERR("ALSA: Failed to initialize...\n");
+   if (params)
+      snd_pcm_hw_params_free(params);
+
+   if (sw_params)
+      snd_pcm_sw_params_free(sw_params);
+
+   alsa_free(alsa);
+
+   return NULL;
+}
+
+static ssize_t alsa_write(void *data, const void *buf, size_t size)
+{
+   alsa_t *alsa = (alsa_t*)data;
+
+   if (alsa->thread_dead)
+      return -1;
+
+   if (alsa->nonblock)
+   {
+      slock_lock(alsa->fifo_lock);
+      size_t avail = fifo_write_avail(alsa->buffer);
+      size_t write_amt = min(avail, size);
+      fifo_write(alsa->buffer, buf, write_amt);
+      slock_unlock(alsa->fifo_lock);
+      return write_amt;
+   }
+   else
+   {
+      size_t written = 0;
+      while (written < size && !alsa->thread_dead)
+      {
+         slock_lock(alsa->fifo_lock);
+         size_t avail = fifo_write_avail(alsa->buffer);
+
+         if (avail == 0)
+         {
+            slock_unlock(alsa->fifo_lock);
+            slock_lock(alsa->cond_lock);
+            if (!alsa->thread_dead)
+               scond_wait(alsa->cond, alsa->cond_lock);
+            slock_unlock(alsa->cond_lock);
+         }
+         else
+         {
+            size_t write_amt = min(size - written, avail);
+            fifo_write(alsa->buffer, (const char*)buf + written, write_amt);
+            slock_unlock(alsa->fifo_lock);
+            written += write_amt;
+         }
+      }
+      return written;
+   }
+}
+
+static bool alsa_stop(void *data)
+{
+   (void)data;
+   return true;
+}
+
+static void alsa_set_nonblock_state(void *data, bool state)
+{
+   alsa_t *alsa = (alsa_t*)data;
+   alsa->nonblock = state;
+}
+
+static bool alsa_start(void *data)
+{
+   (void)data;
+   return true;
+}
+
+static size_t alsa_write_avail(void *data)
+{
+   alsa_t *alsa = (alsa_t*)data;
+
+   if (alsa->thread_dead)
+      return 0;
+   slock_lock(alsa->fifo_lock);
+   size_t val = fifo_write_avail(alsa->buffer);
+   slock_unlock(alsa->fifo_lock);
+   return val;
+}
+
+static size_t alsa_buffer_size(void *data)
+{
+   alsa_t *alsa = (alsa_t*)data;
+   return alsa->buffer_size;
+}
+
+const audio_driver_t audio_alsathread = {
+   alsa_init,
+   alsa_write,
+   alsa_stop,
+   alsa_start,
+   alsa_set_nonblock_state,
+   alsa_free,
+   alsa_use_float,
+   "alsathread",
+   alsa_write_avail,
+   alsa_buffer_size,
+};

audio/coreaudio.c

@@ -0,0 +1,300 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
+ *  Copyright (C) 2011-2013 - Chris Moeller
+ * 
+ *  RetroArch 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.
+ *
+ *  RetroArch 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 RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "driver.h"
+#include "general.h"
+#include "fifo_buffer.h"
+#include <stdlib.h>
+#include "../boolean.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;
+   size_t buffer_size;
+} coreaudio_t;
+
+static void coreaudio_free(void *data)
+{
+   coreaudio_t *dev = (coreaudio_t*)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 = (coreaudio_t*)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 = (coreaudio_t*)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 = {0};
+   desc.componentType = kAudioUnitType_Output;
+   desc.componentSubType = kAudioUnitSubType_HALOutput;
+   desc.componentManufacturer = kAudioUnitManufacturer_Apple;
+
+   AudioStreamBasicDescription stream_desc = {0};
+   AudioStreamBasicDescription real_desc;
+   AudioChannelLayout layout = {0};
+   AURenderCallbackStruct cb = {0};
+
+   Component comp = NULL;
+   OSStatus res = noErr;
+   UInt32 i_size = 0;
+   size_t fifo_size;
+
+   comp = FindNextComponent(NULL, &desc);
+   if (comp == NULL)
+      goto error;
+
+   res = OpenAComponent(comp, &dev->dev);
+   if (res != noErr)
+      goto error;
+
+   dev->dev_alive = true;
+
+   stream_desc.mSampleRate = rate;
+   stream_desc.mBitsPerChannel = sizeof(float) * CHAR_BIT;
+   stream_desc.mChannelsPerFrame = 2;
+   stream_desc.mBytesPerPacket = 2 * sizeof(float);
+   stream_desc.mBytesPerFrame = 2 * sizeof(float);
+   stream_desc.mFramesPerPacket = 1;
+   stream_desc.mFormatID = kAudioFormatLinearPCM;
+   stream_desc.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;
+
+   i_size = sizeof(real_desc);
+   res = AudioUnitGetProperty(dev->dev, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, &real_desc, &i_size);
+   if (res != noErr)
+      goto error;
+
+   RARCH_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;
+
+   layout.mChannelLayoutTag = kAudioChannelLayoutTag_UseChannelBitmap;
+   layout.mChannelBitmap = 0x03;
+
+   res = AudioUnitSetProperty(dev->dev, kAudioUnitProperty_AudioChannelLayout,
+         kAudioUnitScope_Input, 0, &layout, sizeof(layout));
+   if (res != noErr)
+      goto error;
+
+   cb.inputProc = audio_cb;
+   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;
+
+   fifo_size = (latency * g_settings.audio.out_rate) / 1000;
+   fifo_size *= 2 * sizeof(float);
+   dev->buffer_size = fifo_size;
+
+   dev->buffer = fifo_new(fifo_size);
+   if (!dev->buffer)
+      goto error;
+
+   RARCH_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:
+   RARCH_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 = (coreaudio_t*)data;
+
+   const uint8_t *buf = (const uint8_t*)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 = (coreaudio_t*)data;
+   return AudioOutputUnitStop(dev->dev) == noErr;
+}
+
+static void coreaudio_set_nonblock_state(void *data, bool state)
+{
+   coreaudio_t *dev = (coreaudio_t*)data;
+   dev->nonblock = state;
+}
+
+static bool coreaudio_start(void *data)
+{
+   coreaudio_t *dev = (coreaudio_t*)data;
+   return AudioOutputUnitStart(dev->dev) == noErr;
+}
+
+static bool coreaudio_use_float(void *data)
+{
+   (void)data;
+   return true;
+}
+
+static size_t coreaudio_write_avail(void *data)
+{
+   coreaudio_t *dev = (coreaudio_t*)data;
+   pthread_mutex_lock(&dev->lock);
+   size_t avail = fifo_write_avail(dev->buffer);
+   pthread_mutex_unlock(&dev->lock);
+   return avail;
+}
+
+static size_t coreaudio_buffer_size(void *data)
+{
+   coreaudio_t *dev = (coreaudio_t*)data;
+   return dev->buffer_size;
+}
+
+const audio_driver_t audio_coreaudio = {
+   coreaudio_init,
+   coreaudio_write,
+   coreaudio_stop,
+   coreaudio_start,
+   coreaudio_set_nonblock_state,
+   coreaudio_free,
+   coreaudio_use_float,
+   "coreaudio",
+   coreaudio_write_avail,
+   coreaudio_buffer_size,
+};
+

audio/dsound.c

@@ -0,0 +1,471 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
+ *  Copyright (C) 2011-2013 - Daniel De Matteis
+ * 
+ *  RetroArch 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.
+ *
+ *  RetroArch 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 RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(_MSC_VER) && !defined(_XBOX)
+#pragma comment(lib, "dsound")
+#pragma comment(lib, "dxguid")
+#endif
+
+#ifdef _XBOX
+#define DSERR_BUFFERLOST                MAKE_DSHRESULT(150)
+#define DSERR_INVALIDPARAM              E_INVALIDARG
+#define DSERR_PRIOLEVELNEEDED           MAKE_DSHRESULT(70)
+
+// Send the audio signal (stereo, without attenuation) to all existing speakers
+static DSMIXBINVOLUMEPAIR dsmbvp[8] = {
+   { DSMIXBIN_FRONT_LEFT,    DSBVOLUME_MAX },
+   { DSMIXBIN_FRONT_RIGHT,   DSBVOLUME_MAX },
+   { DSMIXBIN_FRONT_CENTER,  DSBVOLUME_MAX },
+   { DSMIXBIN_FRONT_CENTER,  DSBVOLUME_MAX },
+   { DSMIXBIN_BACK_LEFT,     DSBVOLUME_MAX },
+   { DSMIXBIN_BACK_RIGHT,    DSBVOLUME_MAX },
+   { DSMIXBIN_LOW_FREQUENCY, DSBVOLUME_MAX },
+   { DSMIXBIN_LOW_FREQUENCY, DSBVOLUME_MAX },
+};
+   
+static DSMIXBINS dsmb;
+#endif
+
+#include "../driver.h"
+#include <stdlib.h>
+#include "../boolean.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)
+   {
+      RARCH_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 = (dsound_t*)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 = (dsound_t*)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);
+   }
+}
+
+struct dsound_dev
+{
+   unsigned device;
+   unsigned total_count;
+   LPGUID guid;
+};
+
+static BOOL CALLBACK enumerate_cb(LPGUID guid, LPCSTR desc, LPCSTR module, LPVOID context)
+{
+   struct dsound_dev *dev = (struct dsound_dev*)context;
+   RARCH_LOG("\t%u: %s\n", dev->total_count, desc);
+   if (dev->device == dev->total_count)
+      dev->guid = guid;
+   dev->total_count++;
+   return TRUE;
+}
+
+static void *dsound_init(const char *device, unsigned rate, unsigned latency)
+{
+   WAVEFORMATEX wfx = {0};
+   DSBUFFERDESC bufdesc = {0};
+   struct dsound_dev dev = {0};
+
+   dsound_t *ds = (dsound_t*)calloc(1, sizeof(*ds));
+   if (!ds)
+      goto error;
+
+   InitializeCriticalSection(&ds->crit);
+
+   if (device)
+      dev.device = strtoul(device, NULL, 0);
+
+   RARCH_LOG("DirectSound devices:\n");
+#ifndef _XBOX
+   DirectSoundEnumerate(enumerate_cb, &dev);
+#endif
+
+   if (DirectSoundCreate(dev.guid, &ds->ds, NULL) != DS_OK)
+      goto error;
+
+#ifndef _XBOX
+   if (IDirectSound_SetCooperativeLevel(ds->ds, GetDesktopWindow(), DSSCL_PRIORITY) != DS_OK)
+      goto error;
+#endif
+
+   wfx.wFormatTag = WAVE_FORMAT_PCM;
+   wfx.nChannels = 2;
+   wfx.nSamplesPerSec = rate;
+   wfx.wBitsPerSample = 16;
+   wfx.nBlockAlign = 2 * sizeof(int16_t);
+   wfx.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;
+
+   RARCH_LOG("[DirectSound]: Setting buffer size of %u bytes\n", ds->buffer_size);
+   RARCH_LOG("[DirectSound]: Latency = %u ms\n", (unsigned)((1000 * ds->buffer_size) / wfx.nAvgBytesPerSec));
+
+   bufdesc.dwSize = sizeof(DSBUFFERDESC);
+#ifdef _XBOX
+   bufdesc.dwFlags = 0;
+#else
+   bufdesc.dwFlags = DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_GLOBALFOCUS;
+#endif
+   bufdesc.dwBufferBytes = ds->buffer_size;
+   bufdesc.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_SetVolume(ds->dsb, DSBVOLUME_MAX);
+
+#ifdef _XBOX
+   if(g_extern.console.sound.volume_level == 1)
+   {
+      dsmb.dwMixBinCount = 8;
+      dsmb.lpMixBinVolumePairs = dsmbvp;
+      
+      IDirectSoundBuffer_SetHeadroom(ds->dsb, DSBHEADROOM_MIN);
+      IDirectSoundBuffer_SetMixBins(ds->dsb, &dsmb);
+   }
+#endif
+
+   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:
+   RARCH_ERR("[DirectSound] Error occured in init.\n");
+   dsound_free(ds);
+   return NULL;
+}
+
+static bool dsound_stop(void *data)
+{
+   dsound_t *ds = (dsound_t*)data;
+   dsound_stop_thread(ds);
+   return IDirectSoundBuffer_Stop(ds->dsb) == DS_OK;
+}
+
+static bool dsound_start(void *data)
+{
+   dsound_t *ds = (dsound_t*)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 = (dsound_t*)data;
+   ds->nonblock = state;
+}
+
+static ssize_t dsound_write(void *data, const void *buf_, size_t size)
+{
+   dsound_t *ds = (dsound_t*)data;
+   const uint8_t *buf = (const uint8_t*)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;
+}
+
+static size_t dsound_write_avail(void *data)
+{
+   dsound_t *ds = (dsound_t*)data;
+   EnterCriticalSection(&ds->crit);
+   size_t avail = fifo_write_avail(ds->buffer);
+   LeaveCriticalSection(&ds->crit);
+   return avail;
+}
+
+static size_t dsound_buffer_size(void *data)
+{
+   return 4 * 1024;
+}
+
+const audio_driver_t audio_dsound = {
+   dsound_init,
+   dsound_write,
+   dsound_stop,
+   dsound_start,
+   dsound_set_nonblock_state,
+   dsound_free,
+   NULL,
+   "dsound",
+   dsound_write_avail,
+   dsound_buffer_size,
+};
+

audio/ext/rarch_dsp.h

@@ -0,0 +1,113 @@
+/////
+// API header for external RetroArch DSP plugins.
+//
+//
+
+#ifndef __RARCH_DSP_PLUGIN_H
+#define __RARCH_DSP_PLUGIN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _WIN32
+#ifdef RARCH_DLL_IMPORT
+#define RARCH_API_EXPORT __declspec(dllimport) 
+#else
+#define RARCH_API_EXPORT __declspec(dllexport) 
+#endif
+#define RARCH_API_CALLTYPE __cdecl
+#else
+#define RARCH_API_EXPORT
+#define RARCH_API_CALLTYPE
+#endif
+
+#ifndef RARCH_FALSE
+#define RARCH_FALSE 0
+#endif
+
+#ifndef RARCH_TRUE
+#define RARCH_TRUE 1
+#endif
+
+#define RARCH_DSP_API_VERSION 5
+
+typedef struct rarch_dsp_info
+{
+   // Input sample rate that the DSP plugin receives.
+   float input_rate;
+} rarch_dsp_info_t;
+
+typedef struct rarch_dsp_output
+{
+   // The DSP plugin has to provide the buffering for the output samples.
+   // This is for performance reasons to avoid redundant copying of data.
+   // The samples are laid out in interleaving order: LRLRLRLR
+   // The range of the samples are [-1.0, 1.0]. 
+   // This range cannot be exceeded without horrible audio glitches.
+   const float *samples;
+
+   // Frames which the DSP plugin outputted for the current process.
+   // One frame is here defined as a combined sample of 
+   // left and right channels. 
+   // (I.e. 44.1kHz, 16bit stereo will have 
+   // 88.2k samples/sec and 44.1k frames/sec.)
+   unsigned frames;
+} rarch_dsp_output_t;
+
+typedef struct rarch_dsp_input
+{
+   // Input data for the DSP. The samples are interleaved in order: LRLRLRLR
+   const float *samples;
+
+   // Number of frames for input data.
+   // One frame is here defined as a combined sample of 
+   // left and right channels. 
+   // (I.e. 44.1kHz, 16bit stereo will have 
+   // 88.2k samples/sec and 44.1k frames/sec.)
+   unsigned frames;
+} rarch_dsp_input_t;
+
+typedef struct rarch_dsp_plugin
+{
+   // Creates a handle of the plugin. Returns NULL if failed.
+   void *(*init)(const rarch_dsp_info_t *info);
+
+   // Processes input data. 
+   // The plugin is allowed to return variable sizes for output data.
+   void (*process)(void *data, rarch_dsp_output_t *output, 
+         const rarch_dsp_input_t *input);
+
+   // Frees the handle.
+   void (*free)(void *data);
+
+   // API version used to compile the plugin.
+   // Used to detect mismatches in API.
+   // Must be set to RARCH_DSP_API_VERSION on compile.
+   int api_version;
+
+   // Signal plugin that it may open a configuring window or
+   // something similiar. The behavior of this function
+   // is thus plugin dependent. Implementing this is optional,
+   // and can be set to NULL.
+   void (*config)(void *data);
+
+   // Human readable identification string.
+   const char *ident;
+
+   // Called every frame, allows creating a GUI main loop in the main thread.
+   // GUI events can be processed here in a non-blocking fashion.
+   // Can be set to NULL to ignore it.
+   void (*events)(void *data);
+} rarch_dsp_plugin_t;
+
+// Called by RetroArch at startup to get the callback struct.
+// This is NOT dynamically allocated!
+RARCH_API_EXPORT const rarch_dsp_plugin_t* RARCH_API_CALLTYPE 
+   rarch_dsp_plugin_init(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

audio/hermite.c

@@ -0,0 +1,106 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
+ * 
+ *  RetroArch 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.
+ *
+ *  RetroArch 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 RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// Hermite resampler based on bsnes' audio library.
+
+#include "resampler.h"
+#include <stdlib.h>
+#include <math.h>
+#include "../boolean.h"
+#include "../general.h"
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
+#define CHANNELS 2
+
+struct rarch_resampler
+{
+   float chan_data[CHANNELS][4];
+   double r_frac;
+};
+
+static inline float hermite_kernel(float mu1, float a, float b, float c, float d)
+{
+   float mu2, mu3, m0, m1, a0, a1, a2, a3;
+
+   mu2 = mu1 * mu1;
+   mu3 = mu2 * mu1;
+
+   m0  = (c - a) * 0.5f;
+   m1  = (d - b) * 0.5f;
+
+   a0 = +2 * mu3 - 3 * mu2 + 1;
+   a1 =      mu3 - 2 * mu2 + mu1;
+   a2 =      mu3 -     mu2;
+   a3 = -2 * mu3 + 3 * mu2;
+
+   return (a0 * b) + (a1 * m0) + (a2 * m1) + (a3 * c);
+}
+
+rarch_resampler_t *resampler_new(void)
+{
+   RARCH_LOG("Hermite resampler [C]\n");
+   return (rarch_resampler_t*)calloc(1, sizeof(rarch_resampler_t));
+}
+
+void resampler_process(rarch_resampler_t *re, struct resampler_data *data)
+{
+   double r_step = 1.0 / data->ratio;
+   size_t processed_out = 0;
+
+   size_t in_frames = data->input_frames;
+   const float *in_data = data->data_in;
+   float *out_data = data->data_out;
+
+   size_t i = 0;
+   while (i < in_frames)
+   {
+      while (re->r_frac >= 1.0 && i < in_frames)
+      {
+         re->r_frac -= 1.0;
+         for (unsigned c = 0; c < CHANNELS; c++)
+         {
+            re->chan_data[c][0] = re->chan_data[c][1];
+            re->chan_data[c][1] = re->chan_data[c][2];
+            re->chan_data[c][2] = re->chan_data[c][3];
+            re->chan_data[c][3] = *in_data++;
+         }
+         i++;
+      }
+
+      while (re->r_frac <= 1.0)
+      {
+         re->r_frac += r_step;
+         for (unsigned c = 0; c < CHANNELS; c++)
+         {
+            float res = hermite_kernel((float)re->r_frac, 
+                  re->chan_data[c][0], re->chan_data[c][1],
+                  re->chan_data[c][2], re->chan_data[c][3]);
+            *out_data++ = res;
+         }
+         processed_out++;
+      }
+   }
+
+   data->output_frames = processed_out;
+}
+
+void resampler_free(rarch_resampler_t *re)
+{
+   free(re);
+}
+

audio/jack.c

@@ -1,31 +1,29 @@
-/*  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.
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
  * 
- *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  RetroArch 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;
+ *  RetroArch 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.
+ *  You should have received a copy of the GNU General Public License along with RetroArch.
  *  If not, see <http://www.gnu.org/licenses/>.
  */
 
 
-#include "driver.h"
+#include "../driver.h"
 #include <stdlib.h>
-#include "general.h"
+#include "../general.h"
 
 #include <jack/jack.h>
 #include <jack/types.h>
 #include <jack/ringbuffer.h>
 #include <pthread.h>
 #include <stdint.h>
-#include <stdbool.h>
+#include "../boolean.h"
 #include <string.h>
 #include <assert.h>
 
@@ -41,11 +39,12 @@ typedef struct jack
 
    pthread_cond_t cond;
    pthread_mutex_t cond_lock;
+   size_t buffer_size;
 } jack_t;
 
 static int process_cb(jack_nframes_t nframes, void *data)
 {
-   jack_t *jd = data;
+   jack_t *jd = (jack_t*)data;
    if (nframes <= 0)
    {
       pthread_cond_signal(&jd->cond);
@@ -62,7 +61,7 @@ static int process_cb(jack_nframes_t nframes, void *data)
 
    for (int i = 0; i < 2; i++)
    {
-      jack_default_audio_sample_t *out = jack_port_get_buffer(jd->ports[i], nframes);
+      jack_default_audio_sample_t *out = (jack_default_audio_sample_t*)jack_port_get_buffer(jd->ports[i], nframes);
       assert(out);
       jack_ringbuffer_read(jd->buffer[i], (char*)out, min_avail * sizeof(jack_default_audio_sample_t));
 
@@ -77,7 +76,7 @@ static int process_cb(jack_nframes_t nframes, void *data)
 
 static void shutdown_cb(void *data)
 {
-   jack_t *jd = data;
+   jack_t *jd = (jack_t*)data;
    jd->shutdown = true;
    pthread_cond_signal(&jd->cond);
 }
@@ -86,10 +85,11 @@ static int parse_ports(char **dest_ports, const char **jports)
 {
    int parsed = 0;
 
-   const char *con = strtok(g_settings.audio.device, ",");
+   char *save;
+   const char *con = strtok_r(g_settings.audio.device, ",", &save);
    if (con)
       dest_ports[parsed++] = strdup(con);
-   con = strtok(NULL, ",");
+   con = strtok_r(NULL, ",", &save);
    if (con)
       dest_ports[parsed++] = strdup(con);
 
@@ -103,12 +103,20 @@ static size_t find_buffersize(jack_t *jd, int latency)
 {
    int frames = latency * g_settings.audio.out_rate / 1000;
 
-   int jack_latency = jack_port_get_total_latency(jd->client, jd->ports[0]);
-   SSNES_LOG("JACK: Jack latency is %d frames.\n", jack_latency);
+   jack_latency_range_t range;
+   int jack_latency = 0;
+   for (int i = 0; i < 2; i++)
+   {
+      jack_port_get_latency_range(jd->ports[i], JackPlaybackLatency, &range);
+      if ((int)range.max > jack_latency)
+         jack_latency = range.max;
+   }
+
+   RARCH_LOG("JACK: Jack latency is %d frames.\n", jack_latency);
 
    int buffer_frames = frames - jack_latency;
    int min_buffer_frames = jack_get_buffer_size(jd->client) * 2;
-   SSNES_LOG("JACK: Minimum buffer size is %d frames.\n", min_buffer_frames);
+   RARCH_LOG("JACK: Minimum buffer size is %d frames.\n", min_buffer_frames);
 
    if (buffer_frames < min_buffer_frames)
       buffer_frames = min_buffer_frames;
@@ -116,15 +124,21 @@ static size_t find_buffersize(jack_t *jd, int latency)
    return buffer_frames * sizeof(jack_default_audio_sample_t);
 }
 
-static void* __jack_init(const char* device, int rate, int latency)
+static void *ja_init(const char *device, unsigned rate, unsigned latency)
 {
-   jack_t *jd = calloc(1, sizeof(jack_t));
-   if ( jd == NULL )
+   jack_t *jd = (jack_t*)calloc(1, sizeof(jack_t));
+   if (!jd)
       return NULL;
 
+   pthread_cond_init(&jd->cond, NULL);
+   pthread_mutex_init(&jd->cond_lock, NULL);
+   
    const char **jports = NULL;
+   char *dest_ports[2];
+   size_t bufsize = 0;
+   int parsed = 0;
 
-   jd->client = jack_client_open("SSNES", JackNullOption, NULL);
+   jd->client = jack_client_open("RetroArch", JackNullOption, NULL);
    if (jd->client == NULL)
       goto error;
 
@@ -137,24 +151,36 @@ static void* __jack_init(const char* device, int rate, int latency)
    jd->ports[1] = jack_port_register(jd->client, "right", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
    if (jd->ports[0] == NULL || jd->ports[1] == NULL)
    {
-      SSNES_ERR("Failed to register ports.\n");
+      RARCH_ERR("Failed to register ports.\n");
       goto error;
    }
-
    
-   char *dest_ports[2];
    jports = jack_get_ports(jd->client, NULL, NULL, JackPortIsPhysical | JackPortIsInput);
    if (jports == NULL)
    {
-      SSNES_ERR("Failed to get ports.\n");
+      RARCH_ERR("Failed to get ports.\n");
       goto error;
    }
 
-   int parsed = parse_ports(dest_ports, jports);
+   bufsize = find_buffersize(jd, latency);
+   jd->buffer_size = bufsize;
+
+   RARCH_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)
+      {
+         RARCH_ERR("Failed to create buffers.\n");
+         goto error;
+      }
+   }
+
+   parsed = parse_ports(dest_ports, jports);
 
    if (jack_activate(jd->client) < 0)
    {
-      SSNES_ERR("Failed to activate Jack...\n");
+      RARCH_ERR("Failed to activate Jack...\n");
       goto error;
    }
 
@@ -162,30 +188,14 @@ static void* __jack_init(const char* device, int rate, int latency)
    {
       if (jack_connect(jd->client, jack_port_name(jd->ports[i]), dest_ports[i]))
       {
-         SSNES_ERR("Failed to connect to Jack port.\n");
+         RARCH_ERR("Failed to connect to Jack port.\n");
          goto error;
       }
    }
 
    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;
 
@@ -197,7 +207,7 @@ error:
 
 static size_t write_buffer(jack_t *jd, const float *buf, size_t size)
 {
-   jack_default_audio_sample_t out_deinterleaved_buffer[2][FRAMES(size)];
+   jack_default_audio_sample_t out_deinterleaved_buffer[2][AUDIO_CHUNK_SIZE_NONBLOCKING];
 
    for (int i = 0; i < 2; i++)
       for (size_t j = 0; j < FRAMES(size); j++)
@@ -211,9 +221,11 @@ static size_t write_buffer(jack_t *jd, const float *buf, size_t size)
       if (jd->shutdown)
          return 0;
 
-      size_t avail[2];
-      avail[0] = jack_ringbuffer_write_space(jd->buffer[0]);
-      avail[1] = jack_ringbuffer_write_space(jd->buffer[1]);
+      size_t avail[2] = {
+         jack_ringbuffer_write_space(jd->buffer[0]),
+         jack_ringbuffer_write_space(jd->buffer[1]),
+      };
+
       size_t min_avail = avail[0] < avail[1] ? avail[0] : avail[1];
       min_avail /= sizeof(float);
 
@@ -222,7 +234,10 @@ static size_t write_buffer(jack_t *jd, const float *buf, size_t size)
       if (write_frames > 0)
       {
          for (int i = 0; i < 2; i++)
-            jack_ringbuffer_write(jd->buffer[i], (const char*)&out_deinterleaved_buffer[i][written], write_frames * sizeof(jack_default_audio_sample_t));
+         {
+            jack_ringbuffer_write(jd->buffer[i], (const char*)&out_deinterleaved_buffer[i][written],
+                  write_frames * sizeof(jack_default_audio_sample_t));
+         }
          written += write_frames;
       }
       else
@@ -239,34 +254,34 @@ static size_t write_buffer(jack_t *jd, const float *buf, size_t size)
    return written * sizeof(float) * 2;
 }
 
-static ssize_t __jack_write(void* data, const void* buf, size_t size)
+static ssize_t ja_write(void *data, const void *buf, size_t size)
 {
-   jack_t *jd = data;
+   jack_t *jd = (jack_t*)data;
 
-   return write_buffer(jd, buf, size);
+   return write_buffer(jd, (const float*)buf, size);
 }
 
-static bool __jack_stop(void *data)
+static bool ja_stop(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __jack_set_nonblock_state(void *data, bool state)
+static void ja_set_nonblock_state(void *data, bool state)
 {
-   jack_t *jd = data;
+   jack_t *jd = (jack_t*)data;
    jd->nonblock = state;
 }
 
-static bool __jack_start(void *data)
+static bool ja_start(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __jack_free(void *data)
+static void ja_free(void *data)
 {
-   jack_t *jd = data;
+   jack_t *jd = (jack_t*)data;
 
    jd->shutdown = true;
 
@@ -285,25 +300,34 @@ static void __jack_free(void *data)
    free(jd);
 }
 
-static bool __jack_use_float(void *data)
+static bool ja_use_float(void *data)
 {
    (void)data;
    return true;
 }
 
+static size_t ja_write_avail(void *data)
+{
+   jack_t *jd = (jack_t*)data;
+   return jack_ringbuffer_write_space(jd->buffer[0]);
+}
+
+static size_t ja_buffer_size(void *data)
+{
+   jack_t *jd = (jack_t*)data;
+   return jd->buffer_size;
+}
+
 const audio_driver_t audio_jack = {
-   .init = __jack_init,
-   .write = __jack_write,
-   .stop = __jack_stop,
-   .start = __jack_start,
-   .set_nonblock_state = __jack_set_nonblock_state,
-   .free = __jack_free,
-   .use_float = __jack_use_float,
-   .ident = "jack"
+   ja_init,
+   ja_write,
+   ja_stop,
+   ja_start,
+   ja_set_nonblock_state,
+   ja_free,
+   ja_use_float,
+   "jack",
+   ja_write_avail,
+   ja_buffer_size,
 };
 
-   
-
-
-   
-   

audio/null.c

@@ -0,0 +1,74 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
+ * 
+ *  RetroArch 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.
+ *
+ *  RetroArch 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 RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "../general.h"
+#include "../driver.h"
+
+static void *null_audio_init(const char *device, unsigned rate, unsigned latency)
+{
+   (void)device;
+   (void)rate;
+   (void)latency;
+   return (void*)-1;
+}
+
+static void null_audio_free(void *data)
+{
+   (void)data;
+}
+
+static ssize_t null_audio_write(void *data, const void *buf, size_t size)
+{
+   (void)data;
+   (void)buf;
+
+   return size;
+}
+
+static bool null_audio_stop(void *data)
+{
+   (void)data;
+   return true;
+}
+
+static bool null_audio_start(void *data)
+{
+   (void)data;
+   return true;
+}
+
+static void null_audio_set_nonblock_state(void *data, bool state)
+{
+   (void)data;
+   (void)state;
+}
+
+static bool null_audio_use_float(void *data)
+{
+   (void)data;
+   return true;
+}
+
+const audio_driver_t audio_null = {
+   null_audio_init,
+   null_audio_write,
+   null_audio_stop,
+   null_audio_start,
+   null_audio_set_nonblock_state,
+   null_audio_free,
+   null_audio_use_float,
+   "null",
+};
+

audio/openal.c

@@ -1,24 +1,28 @@
-/*  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.
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
  * 
- *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  RetroArch 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;
+ *  RetroArch 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.
+ *  You should have received a copy of the GNU General Public License along with RetroArch.
  *  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "../driver.h"
 
-#include "driver.h"
+#ifdef __APPLE__
+#include <OpenAL/al.h>
+#include <OpenAL/alc.h>
+#else
 #include <AL/al.h>
 #include <AL/alc.h>
+#endif
+
 #include <time.h>
 #include <string.h>
 
@@ -49,11 +53,11 @@ typedef struct al
 
 } al_t;
 
-static void* __al_init(const char* device, int rate, int latency)
+static void *al_init(const char *device, unsigned rate, unsigned latency)
 {
    (void)device;
-   al_t *al = calloc(1, sizeof(al_t));
-   if ( al == NULL )
+   al_t *al = (al_t*)calloc(1, sizeof(al_t));
+   if (!al)
       return NULL;
 
    al->handle = alcOpenDevice(NULL);
@@ -69,8 +73,8 @@ static void* __al_init(const char* device, int rate, int latency)
    al->rate = rate;
 
    al->num_buffers = (latency * rate * 2 * 2) / (1000 * BUFSIZE);
-   al->buffers = calloc(al->num_buffers, sizeof(ALuint));
-   al->res_buf = calloc(al->num_buffers, sizeof(ALuint));
+   al->buffers = (ALuint*)calloc(al->num_buffers, sizeof(ALuint));
+   al->res_buf = (ALuint*)calloc(al->num_buffers, sizeof(ALuint));
    if (al->buffers == NULL || al->res_buf == NULL)
       goto error;
 
@@ -120,13 +124,12 @@ static bool al_get_buffer(al_t *al, ALuint *buffer)
    if (al->res_ptr == 0)
    {
 #ifndef _WIN32
-      struct timespec tv = {
-         .tv_sec = 0,
-         .tv_nsec = 1000000
-      };
+      struct timespec tv = {0};
+      tv.tv_sec = 0;
+      tv.tv_nsec = 1000000;
 #endif
 
-      for(;;)
+      for (;;)
       {
          if (al_unqueue_buffers(al))
             break;
@@ -146,17 +149,17 @@ static bool al_get_buffer(al_t *al, ALuint *buffer)
    return true;
 }
 
-static size_t al_fill_internal_buf(al_t *al, const void* buf, size_t size)
+static size_t al_fill_internal_buf(al_t *al, const void *buf, size_t size)
 {
-   size_t read_size = (BUFSIZE - al->tmpbuf_ptr > size) ? size : (BUFSIZE - al->tmpbuf_ptr);
+   size_t read_size = (BUFSIZE - al->tmpbuf_ptr > (ssize_t)size) ? size : (BUFSIZE - al->tmpbuf_ptr);
    memcpy(al->tmpbuf + al->tmpbuf_ptr, buf, read_size);
    al->tmpbuf_ptr += read_size;
    return read_size;
 }
 
-static ssize_t __al_write(void* data, const void* buf, size_t size)
+static ssize_t al_write(void *data, const void *buf, size_t size)
 {
-   al_t *al = data;
+   al_t *al = (al_t*)data;
 
    size_t written = 0;
    while (written < size)
@@ -189,32 +192,32 @@ static ssize_t __al_write(void* data, const void* buf, size_t size)
    return size;
 }
 
-static bool __al_stop(void *data)
+static bool al_stop(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __al_set_nonblock_state(void *data, bool state)
+static void al_set_nonblock_state(void *data, bool state)
 {
-   al_t *al = data;
+   al_t *al = (al_t*)data;
    al->nonblock = state;
 }
 
-static bool __al_start(void *data)
+static bool al_start(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __al_free(void *data)
+static void al_free(void *data)
 {
-   al_t *al= data;
+   al_t *al = (al_t*)data;
    if (al)
    {
       alSourceStop(al->source);
       alDeleteSources(1, &al->source);
-      if ( al->buffers )
+      if (al->buffers)
       {
          alDeleteBuffers(al->num_buffers, al->buffers);
          free(al->buffers);
@@ -228,13 +231,13 @@ static void __al_free(void *data)
 }
 
 const audio_driver_t audio_openal = {
-   .init = __al_init,
-   .write = __al_write,
-   .stop = __al_stop,
-   .start = __al_start,
-   .set_nonblock_state = __al_set_nonblock_state,
-   .free = __al_free,
-   .ident = "openal"
+   al_init,
+   al_write,
+   al_stop,
+   al_start,
+   al_set_nonblock_state,
+   al_free,
+   NULL,
+   "openal"
 };
 
-   

audio/opensl.c

@@ -0,0 +1,278 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
+ *  Copyright (C) 2011-2013 - Daniel De Matteis
+ * 
+ *  RetroArch 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.
+ *
+ *  RetroArch 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 RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "../driver.h"
+#include "../general.h"
+#include "../thread.h"
+
+#include <SLES/OpenSLES.h>
+#ifdef ANDROID
+#include <SLES/OpenSLES_Android.h>
+#endif
+
+// Helper macros, COM-style!
+#define SLObjectItf_Realize(a, ...) ((*(a))->Realize(a, __VA_ARGS__))
+#define SLObjectItf_GetInterface(a, ...) ((*(a))->GetInterface(a, __VA_ARGS__))
+#define SLObjectItf_Destroy(a) ((*(a))->Destroy((a)))
+
+#define SLEngineItf_CreateOutputMix(a, ...) ((*(a))->CreateOutputMix(a, __VA_ARGS__))
+#define SLEngineItf_CreateAudioPlayer(a, ...) ((*(a))->CreateAudioPlayer(a, __VA_ARGS__))
+
+#define SLPlayItf_SetPlayState(a, ...) ((*(a))->SetPlayState(a, __VA_ARGS__))
+
+// TODO: Are these sane?
+#define BUFFER_SIZE 8192
+#define BUFFER_COUNT 4
+
+typedef struct sl
+{
+   uint8_t buffer[BUFFER_COUNT][BUFFER_SIZE];
+   unsigned buffer_index;
+   unsigned buffer_ptr;
+   volatile unsigned buffered_blocks;
+
+   SLObjectItf engine_object;
+   SLEngineItf engine;
+
+   SLObjectItf output_mix;
+   SLObjectItf buffer_queue_object;
+   SLAndroidSimpleBufferQueueItf buffer_queue;
+   SLPlayItf player;
+
+   slock_t *lock;
+   scond_t *cond;
+   bool nonblock;
+   unsigned buf_count;
+} sl_t;
+
+static void opensl_callback(SLAndroidSimpleBufferQueueItf bq, void *ctx)
+{
+   sl_t *sl = (sl_t*)ctx;
+
+   slock_lock(sl->lock);
+   sl->buffered_blocks--;
+   slock_unlock(sl->lock);
+
+   scond_signal(sl->cond);
+}
+
+#define GOTO_IF_FAIL(x) do { \
+   if ((res = (x)) != SL_RESULT_SUCCESS) \
+      goto error; \
+} while(0)
+
+static void sl_free(void *data)
+{
+   sl_t *sl = (sl_t*)data;
+   if (!sl)
+      return;
+
+   if (sl->player)
+      SLPlayItf_SetPlayState(sl->player, SL_PLAYSTATE_STOPPED);
+
+   if (sl->buffer_queue_object)
+      SLObjectItf_Destroy(sl->buffer_queue_object);
+
+   if (sl->output_mix)
+      SLObjectItf_Destroy(sl->output_mix);
+
+   if (sl->engine_object)
+      SLObjectItf_Destroy(sl->engine_object);
+
+   if (sl->lock)
+      slock_free(sl->lock);
+   if (sl->cond)
+      scond_free(sl->cond);
+
+   free(sl);
+}
+
+static void *sl_init(const char *device, unsigned rate, unsigned latency)
+{
+   (void)device;
+
+   SLDataFormat_PCM fmt_pcm = {0};
+   SLDataSource audio_src   = {0};
+   SLDataSink audio_sink    = {0};
+
+   SLDataLocator_AndroidSimpleBufferQueue loc_bufq = {0};
+   SLDataLocator_OutputMix loc_outmix              = {0};
+
+   SLInterfaceID id = SL_IID_ANDROIDSIMPLEBUFFERQUEUE;
+   SLboolean req    = SL_BOOLEAN_TRUE;
+
+   SLresult res = 0;
+   sl_t *sl = (sl_t*)calloc(1, sizeof(sl_t));
+   if (!sl)
+      goto error;
+
+   GOTO_IF_FAIL(slCreateEngine(&sl->engine_object, 0, NULL, 0, NULL, NULL));
+   GOTO_IF_FAIL(SLObjectItf_Realize(sl->engine_object, SL_BOOLEAN_FALSE));
+   GOTO_IF_FAIL(SLObjectItf_GetInterface(sl->engine_object, SL_IID_ENGINE, &sl->engine));
+   GOTO_IF_FAIL(SLEngineItf_CreateOutputMix(sl->engine, &sl->output_mix, 0, NULL, NULL));
+   GOTO_IF_FAIL(SLObjectItf_Realize(sl->output_mix, SL_BOOLEAN_FALSE));
+
+   sl->buf_count = BUFFER_COUNT;
+
+   RARCH_LOG("[SLES] : Setting audio latency (buffer size: [%d])..\n", sl->buf_count * BUFFER_SIZE);
+
+   fmt_pcm.formatType    = SL_DATAFORMAT_PCM;
+   fmt_pcm.numChannels   = 2;
+   fmt_pcm.samplesPerSec = rate * 1000; // Samplerate is in milli-Hz.
+   fmt_pcm.bitsPerSample = sizeof(int16_t) * 8;
+   fmt_pcm.containerSize = sizeof(int16_t) * 8;
+   fmt_pcm.channelMask   = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
+   fmt_pcm.endianness    = SL_BYTEORDER_LITTLEENDIAN; // Android only.
+
+   audio_src.pLocator = &loc_bufq;
+   audio_src.pFormat  = &fmt_pcm;
+
+   loc_bufq.locatorType = SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE;
+   loc_bufq.numBuffers  = sl->buf_count;
+
+   loc_outmix.locatorType = SL_DATALOCATOR_OUTPUTMIX;
+   loc_outmix.outputMix   = sl->output_mix;
+
+   audio_sink.pLocator = &loc_outmix;
+
+   GOTO_IF_FAIL(SLEngineItf_CreateAudioPlayer(sl->engine, &sl->buffer_queue_object,
+            &audio_src, &audio_sink,
+            1, &id, &req));
+   GOTO_IF_FAIL(SLObjectItf_Realize(sl->buffer_queue_object, SL_BOOLEAN_FALSE));
+
+   GOTO_IF_FAIL(SLObjectItf_GetInterface(sl->buffer_queue_object, SL_IID_BUFFERQUEUE,
+            &sl->buffer_queue));
+
+   sl->cond = scond_new();
+   sl->lock = slock_new();
+
+   (*sl->buffer_queue)->RegisterCallback(sl->buffer_queue, opensl_callback, sl);
+
+   // Enqueue a bit to get stuff rolling.
+   sl->buffered_blocks = BUFFER_COUNT;
+   sl->buffer_index = 0;
+   for (unsigned i = 0; i < BUFFER_COUNT; i++)
+      (*sl->buffer_queue)->Enqueue(sl->buffer_queue, sl->buffer[i], BUFFER_SIZE);
+
+   GOTO_IF_FAIL(SLObjectItf_GetInterface(sl->buffer_queue_object, SL_IID_PLAY, &sl->player));
+   GOTO_IF_FAIL(SLPlayItf_SetPlayState(sl->player, SL_PLAYSTATE_PLAYING));
+
+   return sl;
+
+error:
+   RARCH_ERR("Couldn't initialize OpenSL ES driver, error code: [%d].\n", (int)res);
+   sl_free(sl);
+   return NULL;
+}
+
+static bool sl_stop(void *data)
+{
+   sl_t *sl = (sl_t*)data;
+   return SLPlayItf_SetPlayState(sl->player, SL_PLAYSTATE_STOPPED) == SL_RESULT_SUCCESS;
+}
+
+static void sl_set_nonblock_state(void *data, bool state)
+{
+   sl_t *sl = (sl_t*)data;
+   sl->nonblock = state;
+}
+
+static bool sl_start(void *data)
+{
+   sl_t *sl = (sl_t*)data;
+   return SLPlayItf_SetPlayState(sl->player, SL_PLAYSTATE_PLAYING) == SL_RESULT_SUCCESS;
+}
+
+
+static ssize_t sl_write(void *data, const void *buf_, size_t size)
+{
+   sl_t *sl = (sl_t*)data;
+
+   size_t written = 0;
+   const uint8_t *buf = (const uint8_t*)buf_;
+
+   while (size)
+   {
+      slock_lock(sl->lock);
+      if (sl->nonblock)
+      {
+         if (sl->buffered_blocks == BUFFER_COUNT)
+         {
+            slock_unlock(sl->lock);
+            break;
+         }
+      }
+      else
+      {
+         while (sl->buffered_blocks == BUFFER_COUNT)
+            scond_wait(sl->cond, sl->lock);
+      }
+      slock_unlock(sl->lock);
+
+      size_t avail_write = min(BUFFER_SIZE - sl->buffer_ptr, size);
+      if (avail_write)
+      {
+         memcpy(sl->buffer[sl->buffer_index] + sl->buffer_ptr, buf, avail_write);
+         sl->buffer_ptr += avail_write;
+         buf            += avail_write;
+         size           -= avail_write;
+         written        += avail_write;
+      }
+
+      if (sl->buffer_ptr >= BUFFER_SIZE)
+      {
+         slock_lock(sl->lock);
+         (*sl->buffer_queue)->Enqueue(sl->buffer_queue, sl->buffer[sl->buffer_index], BUFFER_SIZE);
+         sl->buffer_index = (sl->buffer_index + 1) & (BUFFER_COUNT - 1);
+         sl->buffered_blocks++;
+         slock_unlock(sl->lock);
+         sl->buffer_ptr = 0;
+      }
+   }
+
+   //RARCH_LOG("Blocks: %u\n", sl->buffered_blocks);
+
+   return written;
+}
+
+static size_t sl_write_avail(void *data)
+{
+   sl_t *sl = (sl_t*)data;
+   slock_lock(sl->lock);
+   size_t avail = (BUFFER_COUNT - (int)sl->buffered_blocks - 1) * BUFFER_SIZE + (BUFFER_SIZE - (int)sl->buffer_ptr);
+   slock_unlock(sl->lock);
+   return avail;
+}
+
+static size_t sl_buffer_size(void *data)
+{
+   (void)data;
+   return BUFFER_SIZE * BUFFER_COUNT;
+}
+
+const audio_driver_t audio_opensl = {
+   sl_init,
+   sl_write,
+   sl_stop,
+   sl_start,
+   sl_set_nonblock_state,
+   sl_free,
+   NULL,
+   "opensl",
+   sl_write_avail,
+   sl_buffer_size,
+};
+

audio/oss.c

@@ -1,147 +1,196 @@
-/*  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.
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
  * 
- *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  RetroArch 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;
+ *  RetroArch 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.
+ *  You should have received a copy of the GNU General Public License along with RetroArch.
  *  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
 
 #include "driver.h"
+#include "general.h"
 #include <stdlib.h>
+
+#ifdef HAVE_OSS_BSD
+#include <soundcard.h>
+#else
 #include <sys/soundcard.h>
+#endif
+
 #include <fcntl.h>
 #include <sys/ioctl.h>
 #include <unistd.h>
 #include <errno.h>
 #include <stdio.h>
 
-static void* __oss_init(const char* device, int rate, int latency)
+#ifdef HAVE_OSS_BSD
+#define DEFAULT_OSS_DEV "/dev/audio"
+#else
+#define DEFAULT_OSS_DEV "/dev/dsp"
+#endif
+
+static void *oss_init(const char *device, unsigned rate, unsigned latency)
 {
-   int *fd = calloc(1, sizeof(int));
-   if ( fd == NULL )
+   int *fd = (int*)calloc(1, sizeof(int));
+   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);
+      perror("open");
       return NULL;
    }
 
-   int frags = (latency * rate * 4)/(1000 * (1 << 9));
-   int frag = (frags << 16) | 9;
+   int frags = (latency * rate * 4) / (1000 * (1 << 10));
+   int frag = (frags << 16) | 10;
 
-   if ( ioctl(*fd, SNDCTL_DSP_SETFRAGMENT, &frag) < 0 )
-   {
-      close(*fd);
-      free(fd);
-      return NULL;
-   }
+   if (ioctl(*fd, SNDCTL_DSP_SETFRAGMENT, &frag) < 0)
+      RARCH_WARN("Cannot set fragment sizes. Latency might not be as expected ...\n");
 
    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);
+      perror("ioctl");
       return NULL;
    }
 
-   if ( ioctl(*fd, SNDCTL_DSP_SETFMT, &format) < 0 )
+   if (ioctl(*fd, SNDCTL_DSP_SETFMT, &format) < 0)
    {
       close(*fd);
       free(fd);
+      perror("ioctl");
       return NULL;
    }
 
-   if ( ioctl(*fd, SNDCTL_DSP_SPEED, &rate) < 0 )
+   int new_rate = rate;
+   if (ioctl(*fd, SNDCTL_DSP_SPEED, &new_rate) < 0)
    {
       close(*fd);
       free(fd);
+      perror("ioctl");
       return NULL;
    }
 
+   if (new_rate != (int)rate)
+   {
+      RARCH_WARN("Requested sample rate not supported. Adjusting output rate to %d Hz.\n", new_rate);
+      g_settings.audio.out_rate = new_rate;
+   }
+
    return fd;
 }
 
-static ssize_t __oss_write(void* data, const void* buf, size_t size)
+static ssize_t oss_write(void *data, const void *buf, size_t size)
 {
-   int *fd = data;
+   int *fd = (int*)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 (errno == EAGAIN && (fcntl(*fd, F_GETFL) & O_NONBLOCK))
          return 0;
+
       return -1;
    }
 
    return ret;
 }
 
-static bool __oss_stop(void *data)
+static bool oss_stop(void *data)
 {
-   int *fd = data;
+   int *fd = (int*)data;
    ioctl(*fd, SNDCTL_DSP_RESET, 0);
    return true;
 }
 
-static bool __oss_start(void *data)
+static bool oss_start(void *data)
 {
    return true;
 }
 
-static void __oss_set_nonblock_state(void *data, bool state)
+static void oss_set_nonblock_state(void *data, bool state)
 {
-   int *fd = data;
+   int *fd = (int*)data;
    int rc;
    if (state)
       rc = fcntl(*fd, F_SETFL, fcntl(*fd, F_GETFL) | O_NONBLOCK);
    else
       rc = fcntl(*fd, F_SETFL, fcntl(*fd, F_GETFL) & (~O_NONBLOCK));
    if (rc != 0)
-      fprintf(stderr, "SSNES [ERROR]: Could not set nonblocking on OSS file descriptor. Will not be able to fast-forward.\n");
+      RARCH_WARN("Could not set nonblocking on OSS file descriptor. Will not be able to fast-forward.\n");
 }
 
-static void __oss_free(void *data)
+static void oss_free(void *data)
 {
-   int *fd = data;
+   int *fd = (int*)data;
 
    ioctl(*fd, SNDCTL_DSP_RESET, 0);
    close(*fd);
    free(fd);
 }
 
+static size_t oss_write_avail(void *data)
+{
+   int *fd = (int*)data;
+
+   audio_buf_info info;
+   if (ioctl(*fd, SNDCTL_DSP_GETOSPACE, &info) < 0)
+   {
+      RARCH_ERR("SNDCTL_DSP_GETOSPACE failed ...\n");
+      return 0;
+   }
+
+   return info.bytes;
+}
+
+static size_t oss_buffer_size(void *data)
+{
+   int *fd = (int*)data;
+
+   audio_buf_info info;
+   if (ioctl(*fd, SNDCTL_DSP_GETOSPACE, &info) < 0)
+   {
+      RARCH_ERR("SNDCTL_DSP_GETOSPACE failed ...\n");
+      return 1; // Return something non-zero to avoid SIGFPE.
+   }
+
+   return info.fragsize * info.fragstotal;
+}
+
 const audio_driver_t audio_oss = {
-   .init = __oss_init,
-   .write = __oss_write,
-   .stop = __oss_stop,
-   .start = __oss_start,
-   .set_nonblock_state = __oss_set_nonblock_state,
-   .free = __oss_free,
-   .ident = "oss"
+   oss_init,
+   oss_write,
+   oss_stop,
+   oss_start,
+   oss_set_nonblock_state,
+   oss_free,
+   NULL,
+   "oss",
+   oss_write_avail,
+   oss_buffer_size,
 };
 
-   
-
-
-   
-   

audio/pulse.c

@@ -0,0 +1,252 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
+ * 
+ *  RetroArch 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.
+ *
+ *  RetroArch 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 RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "driver.h"
+#include "general.h"
+#include <pulse/pulseaudio.h>
+#include "../boolean.h"
+#include <string.h>
+
+#include <stdio.h>
+
+typedef struct
+{
+   pa_threaded_mainloop *mainloop;
+   pa_context *context;
+   pa_stream *stream;
+   bool nonblock;
+   size_t buffer_size;
+} pa_t;
+
+static void pulse_free(void *data)
+{
+   pa_t *pa = (pa_t*)data;
+   if (pa)
+   {
+      if (pa->mainloop)
+         pa_threaded_mainloop_stop(pa->mainloop);
+
+      if (pa->stream)
+      {
+         pa_stream_disconnect(pa->stream);
+         pa_stream_unref(pa->stream);
+      }
+
+      if (pa->context)
+      {
+         pa_context_disconnect(pa->context);
+         pa_context_unref(pa->context);
+      }
+
+      if (pa->mainloop)
+         pa_threaded_mainloop_free(pa->mainloop);
+
+      free(pa);
+   }
+}
+
+static void context_state_cb(pa_context *c, void *data)
+{
+   pa_t *pa = (pa_t*)data;
+   switch (pa_context_get_state(c))
+   {
+      case PA_CONTEXT_READY:
+      case PA_CONTEXT_TERMINATED:
+      case PA_CONTEXT_FAILED:
+         pa_threaded_mainloop_signal(pa->mainloop, 0);
+         break;
+      default:
+         break;
+   }
+}
+
+static void stream_state_cb(pa_stream *s, void *data) 
+{
+   pa_t *pa = (pa_t*)data;
+   switch (pa_stream_get_state(s))
+   {
+      case PA_STREAM_READY:
+      case PA_STREAM_FAILED:
+      case PA_STREAM_TERMINATED:
+         pa_threaded_mainloop_signal(pa->mainloop, 0);
+         break;
+      default:
+         break;
+   }
+}
+
+static void stream_request_cb(pa_stream *s, size_t length, void *data) 
+{
+   (void)length;
+   (void)s;
+   pa_t *pa = (pa_t*)data;
+   pa_threaded_mainloop_signal(pa->mainloop, 0);
+}
+
+static void stream_latency_update_cb(pa_stream *s, void *data) 
+{
+   (void)s;
+   pa_t *pa = (pa_t*)data;
+   pa_threaded_mainloop_signal(pa->mainloop, 0);
+}
+
+static void *pulse_init(const char *device, unsigned rate, unsigned latency)
+{
+   pa_sample_spec spec;
+   memset(&spec, 0, sizeof(spec));
+   pa_buffer_attr buffer_attr = {0};
+
+   pa_t *pa = (pa_t*)calloc(1, sizeof(*pa));
+   if (!pa)
+      goto error;
+
+   pa->mainloop = pa_threaded_mainloop_new();
+   if (!pa->mainloop)
+      goto error;
+
+   pa->context = pa_context_new(pa_threaded_mainloop_get_api(pa->mainloop), "RetroArch");
+   if (!pa->context)
+      goto error;
+
+   pa_context_set_state_callback(pa->context, context_state_cb, pa);
+
+   if (pa_context_connect(pa->context, device, PA_CONTEXT_NOFLAGS, NULL) < 0)
+      goto error;
+
+   pa_threaded_mainloop_lock(pa->mainloop);
+   if (pa_threaded_mainloop_start(pa->mainloop) < 0)
+      goto error;
+
+   pa_threaded_mainloop_wait(pa->mainloop);
+
+   if (pa_context_get_state(pa->context) != PA_CONTEXT_READY)
+      goto unlock_error;
+
+   spec.format = is_little_endian() ? PA_SAMPLE_FLOAT32LE : PA_SAMPLE_FLOAT32BE;
+   spec.channels = 2;
+   spec.rate = rate;
+
+   pa->stream = pa_stream_new(pa->context, "audio", &spec, NULL);
+   if (!pa->stream)
+      goto unlock_error;
+
+   pa_stream_set_state_callback(pa->stream, stream_state_cb, pa);
+   pa_stream_set_write_callback(pa->stream, stream_request_cb, pa);
+   pa_stream_set_latency_update_callback(pa->stream, stream_latency_update_cb, pa);
+
+   buffer_attr.maxlength = -1;
+   buffer_attr.tlength = pa_usec_to_bytes(latency * PA_USEC_PER_MSEC, &spec);
+   buffer_attr.prebuf = -1;
+   buffer_attr.minreq = -1;
+   buffer_attr.fragsize = -1;
+
+   pa->buffer_size = buffer_attr.tlength;
+
+   if (pa_stream_connect_playback(pa->stream, NULL, &buffer_attr, PA_STREAM_ADJUST_LATENCY, NULL, NULL) < 0)
+      goto error;
+
+   pa_threaded_mainloop_wait(pa->mainloop);
+
+   if (pa_stream_get_state(pa->stream) != PA_STREAM_READY)
+      goto unlock_error;
+
+   pa_threaded_mainloop_unlock(pa->mainloop);
+
+   return pa;
+
+unlock_error:
+   pa_threaded_mainloop_unlock(pa->mainloop);
+error:
+   pulse_free(pa); 
+   return NULL;
+}
+
+static ssize_t pulse_write(void *data, const void *buf, size_t size)
+{
+   pa_t *pa = (pa_t*)data;
+
+   pa_threaded_mainloop_lock(pa->mainloop);
+   size_t length = pa_stream_writable_size(pa->stream);
+   pa_threaded_mainloop_unlock(pa->mainloop);
+
+   while (length < size && !pa->nonblock)
+   {
+      pa_threaded_mainloop_lock(pa->mainloop);
+      pa_threaded_mainloop_wait(pa->mainloop);
+      length = pa_stream_writable_size(pa->stream);
+      pa_threaded_mainloop_unlock(pa->mainloop);
+   }
+
+   size_t write_size = min(length, size);
+
+   pa_threaded_mainloop_lock(pa->mainloop);
+   pa_stream_write(pa->stream, buf, write_size, NULL, 0LL, PA_SEEK_RELATIVE);
+   pa_threaded_mainloop_unlock(pa->mainloop);
+   return write_size;
+}
+
+static bool pulse_stop(void *data)
+{
+   (void)data;
+   return true;
+}
+
+static bool pulse_start(void *data)
+{
+   (void)data;
+   return true;
+}
+
+static void pulse_set_nonblock_state(void *data, bool state)
+{
+   pa_t *pa = (pa_t*)data;
+   pa->nonblock = state;
+}
+
+static bool pulse_use_float(void *data)
+{
+   (void)data;
+   return true;
+}
+
+static size_t pulse_write_avail(void *data)
+{
+   pa_t *pa = (pa_t*)data;
+   pa_threaded_mainloop_lock(pa->mainloop);
+   size_t length = pa_stream_writable_size(pa->stream);
+   pa_threaded_mainloop_unlock(pa->mainloop);
+   return length;
+}
+
+static size_t pulse_buffer_size(void *data)
+{
+   pa_t *pa = (pa_t*)data;
+   return pa->buffer_size;
+}
+
+const audio_driver_t audio_pulse = {
+   pulse_init,
+   pulse_write,
+   pulse_stop,
+   pulse_start,
+   pulse_set_nonblock_state,
+   pulse_free,
+   pulse_use_float,
+   "pulse",
+   pulse_write_avail,
+   pulse_buffer_size,
+};
+

audio/resampler.h

@@ -0,0 +1,52 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
+ * 
+ *  RetroArch 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.
+ *
+ *  RetroArch 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 RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef __RARCH_RESAMPLER_H
+#define __RARCH_RESAMPLER_H
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
+#include <stddef.h>
+#include <stdint.h>
+#include <math.h>
+
+// M_PI is left out of ISO C99 :(
+#ifndef M_PI
+#define M_PI 3.14159265358979323846264338327
+#endif
+
+typedef struct rarch_resampler rarch_resampler_t;
+typedef float sample_t;
+
+struct resampler_data
+{
+   const sample_t *data_in;
+   sample_t *data_out;
+
+   size_t input_frames;
+   size_t output_frames;
+
+   double ratio;
+};
+
+rarch_resampler_t *resampler_new(void);
+void resampler_process(rarch_resampler_t *re, struct resampler_data *data);
+void resampler_free(rarch_resampler_t *re);
+
+#endif
+

audio/roar.c

@@ -1,17 +1,15 @@
-/*  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.
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
  * 
- *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  RetroArch 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;
+ *  RetroArch 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.
+ *  You should have received a copy of the GNU General Public License along with RetroArch.
  *  If not, see <http://www.gnu.org/licenses/>.
  */
 
@@ -21,7 +19,8 @@
 #include <roaraudio.h>
 #include <errno.h>
 #include <stdio.h>
-#include <stdbool.h>
+#include "../boolean.h"
+#include "general.h"
 
 typedef struct
 {
@@ -29,44 +28,47 @@ typedef struct
    bool nonblocking;
 } roar_t;
 
-static void* __roar_init(const char* device, int rate, int latency)
+static void *ra_init(const char *device, unsigned rate, unsigned latency)
 {
+   (void)latency;
    int err;
-   roar_t *roar = calloc(1, sizeof(roar_t));
+   roar_t *roar = (roar_t*)calloc(1, sizeof(roar_t));
    if (roar == NULL)
       return NULL;
 
    roar_vs_t *vss;
-   if ( (vss = roar_vs_new_simple(NULL, NULL, rate, 2, ROAR_CODEC_PCM_S_LE, 16, ROAR_DIR_PLAY, &err)) == NULL )
+   if ((vss = roar_vs_new_simple(device, "RetroArch", rate, 2, ROAR_CODEC_PCM_S, 16, ROAR_DIR_PLAY, &err)) == NULL)
    {
-      fprintf(stderr, "roar_vs: \"%s\"\n", roar_vs_strerr(err));
+      RARCH_ERR("RoarAudio: \"%s\"\n", roar_vs_strerr(err));
       free(roar);
       return NULL;
    }
 
+   roar_vs_role(vss, ROAR_ROLE_GAME, NULL);
    roar->vss = vss;
 
    return roar;
 }
 
-static ssize_t __roar_write(void* data, const void* buf, size_t size)
+static ssize_t ra_write(void *data, const void *buf, size_t size)
 {
-   roar_t *roar = data;
+   roar_t *roar = (roar_t*)data;
    ssize_t rc;
 
-   if ( size == 0 )
+   if (size == 0)
       return 0;
 
    int err;
    size_t written = 0;
    while (written < size)
    {
-      if ((rc = roar_vs_write(roar->vss, (const char*)buf + written, size - written, &err)) < size)
+      size_t write_amt = size - written;
+      if ((rc = roar_vs_write(roar->vss, (const char*)buf + written, write_amt, &err)) < (ssize_t)write_amt)
       {
-         if (rc < 0)
+         if (roar->nonblocking)
+            return rc;
+         else if (rc < 0)
             return -1;
-         else if (roar->nonblocking)
-            return 0;
       }
       written += rc;
    }
@@ -74,45 +76,41 @@ static ssize_t __roar_write(void* data, const void* buf, size_t size)
    return size;
 }
 
-static bool __roar_stop(void *data)
+static bool ra_stop(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __roar_set_nonblock_state(void *data, bool state)
+static void ra_set_nonblock_state(void *data, bool state)
 {
-   roar_t *roar = data;
+   roar_t *roar = (roar_t*)data;
    if (roar_vs_blocking(roar->vss, (state) ? ROAR_VS_FALSE : ROAR_VS_TRUE, NULL) < 0)
-      fprintf(stderr, "SSNES [ERROR]: Can't set nonblocking. Will not be able to fast-forward.\n");
+      fprintf(stderr, "RetroArch [ERROR]: Can't set nonblocking. Will not be able to fast-forward.\n");
    roar->nonblocking = state;
 }
 
-static bool __roar_start(void *data)
+static bool ra_start(void *data)
 {
    (void)data;
    return true;
 }
 
-static void __roar_free(void *data)
+static void ra_free(void *data)
 {
-   roar_t *roar = data;
+   roar_t *roar = (roar_t*)data;
    roar_vs_close(roar->vss, ROAR_VS_TRUE, NULL);
    free(data);
 }
 
 const audio_driver_t audio_roar = {
-   .init = __roar_init,
-   .write = __roar_write,
-   .stop = __roar_stop,
-   .start = __roar_start,
-   .set_nonblock_state = __roar_set_nonblock_state,
-   .free = __roar_free,
-   .ident = "roar"
+   ra_init,
+   ra_write,
+   ra_stop,
+   ra_start,
+   ra_set_nonblock_state,
+   ra_free,
+   NULL,
+   "roar"
 };
 
-   
-
-
-   
-   

audio/rsound.c

@@ -1,146 +1,216 @@
-/*  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.
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
  * 
- *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  RetroArch 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;
+ *  RetroArch 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.
+ *  You should have received a copy of the GNU General Public License along with RetroArch.
  *  If not, see <http://www.gnu.org/licenses/>.
  */
 
 
-#include "driver.h"
+#include "../driver.h"
 #include <stdlib.h>
+#ifdef RARCH_CONSOLE
+#include "../deps/librsound/rsound.h"
+#else
 #include <rsound.h>
+#endif
+#include "fifo_buffer.h"
+#include "../boolean.h"
+#include "../thread.h"
 
 typedef struct rsd
 {
    rsound_t *rd;
-   int latency;
-   int rate;
-   int nonblock;
+   bool nonblock;
+   volatile bool has_error;
+
+   fifo_buffer_t *buffer;
+
+   slock_t *cond_lock;
+   scond_t *cond;
 } rsd_t;
 
-static void* __rsd_init(const char* device, int rate, int latency)
+static ssize_t audio_cb(void *data, size_t bytes, void *userdata)
 {
-   rsd_t *rsd = calloc(1, sizeof(rsd_t));
-   if ( rsd == NULL )
+   rsd_t *rsd = (rsd_t*)userdata;
+
+   size_t avail = fifo_read_avail(rsd->buffer);
+   size_t write_size = bytes > avail ? avail : bytes;
+   fifo_read(rsd->buffer, data, write_size);
+   scond_signal(rsd->cond);
+
+   return write_size;
+}
+
+static void err_cb(void *userdata)
+{
+   rsd_t *rsd = (rsd_t*)userdata;
+   rsd->has_error = true;
+   scond_signal(rsd->cond);
+}
+
+static void *rs_init(const char *device, unsigned rate, unsigned latency)
+{
+   rsd_t *rsd = (rsd_t*)calloc(1, sizeof(rsd_t));
+   if (!rsd)
       return NULL;
 
    rsound_t *rd;
 
-   if ( rsd_init(&rd) < 0 )
+   if (rsd_init(&rd) < 0)
    {
       free(rsd);
       return NULL;
    }
 
+   rsd->cond_lock = slock_new();
+   rsd->cond = scond_new();
+
+   rsd->buffer = fifo_new(1024 * 4);
+
    int channels = 2;
    int format = RSD_S16_NE;
 
    rsd_set_param(rd, RSD_CHANNELS, &channels);
    rsd_set_param(rd, RSD_SAMPLERATE, &rate);
+   rsd_set_param(rd, RSD_LATENCY, &latency);
 
-   if ( device != NULL )
+   if (device)
       rsd_set_param(rd, RSD_HOST, (void*)device);
 
    rsd_set_param(rd, RSD_FORMAT, &format);
 
-   if ( rsd_start(rd) < 0 )
+   rsd_set_callback(rd, audio_cb, err_cb, 256, rsd);
+
+   if (rsd_start(rd) < 0)
    {
       free(rsd);
       rsd_free(rd);
       return NULL;
    }
 
-   int min_latency = (rsd_delay_ms(rd) > latency) ? (rsd_delay_ms(rd) * 3 / 2) : latency;
-
-   rsd_set_param(rd, RSD_LATENCY, &min_latency);
-
    rsd->rd = rd;
-   rsd->latency = min_latency;
-   rsd->rate = rate;
-
    return rsd;
 }
 
-static ssize_t __rsd_write(void* data, const void* buf, size_t size)
+static ssize_t rs_write(void *data, const void *buf, size_t size)
 {
-   rsd_t *rsd = data;
+   rsd_t *rsd = (rsd_t*)data;
 
-   if ( (rsd_delay_ms(rsd->rd) > rsd->latency || rsd_get_avail(rsd->rd) < size) && rsd->nonblock )
-      return 0;
-
-   if ( size == 0 )
-      return 0;
-
-   rsd_delay_wait(rsd->rd);
-   if ( rsd_write(rsd->rd, buf, size) == 0 )
+   if (rsd->has_error)
       return -1;
 
-   if ( rsd_delay_ms(rsd->rd) < rsd->latency/2 )
+   if (rsd->nonblock)
    {
-      int ms = rsd->latency/2;
-      size_t size = (ms * rsd->rate * 4) / 1000;
-      void *temp = calloc(1, size);
-      rsd_write(rsd->rd, temp, size);
-      free(temp);
+      rsd_callback_lock(rsd->rd);
+      size_t avail = fifo_write_avail(rsd->buffer);
+      size_t write_amt = avail > size ? size : avail;
+      fifo_write(rsd->buffer, buf, write_amt);
+      rsd_callback_unlock(rsd->rd);
+      return write_amt;
    }
+   else
+   {
+      size_t written = 0;
+      while (written < size && !rsd->has_error)
+      {
+         rsd_callback_lock(rsd->rd);
+         size_t avail = fifo_write_avail(rsd->buffer);
 
-   return size;
+         if (avail == 0)
+         {
+            rsd_callback_unlock(rsd->rd);
+            if (!rsd->has_error)
+            {
+               slock_lock(rsd->cond_lock);
+               scond_wait(rsd->cond, rsd->cond_lock);
+               slock_unlock(rsd->cond_lock);
+            }
+         }
+         else
+         {
+            size_t write_amt = size - written > avail ? avail : size - written;
+            fifo_write(rsd->buffer, (const char*)buf + written, write_amt);
+            rsd_callback_unlock(rsd->rd);
+            written += write_amt;
+         }
+      }
+      return written;
+   }
 }
 
-static bool __rsd_stop(void *data)
+static bool rs_stop(void *data)
 {
-   rsd_t *rsd = data;
+   rsd_t *rsd = (rsd_t*)data;
    rsd_stop(rsd->rd);
 
    return true;
 }
 
-static void __rsd_set_nonblock_state(void *data, bool state)
+static void rs_set_nonblock_state(void *data, bool state)
 {
-   rsd_t *rsd = data;
+   rsd_t *rsd = (rsd_t*)data;
    rsd->nonblock = state;
 }
 
-static bool __rsd_start(void *data)
+static bool rs_start(void *data)
 {
-   rsd_t *rsd = data;
-   if ( rsd_start(rsd->rd) < 0)
+   rsd_t *rsd = (rsd_t*)data;
+   if (rsd_start(rsd->rd) < 0)
       return false;
 
    return true;
 }
 
-static void __rsd_free(void *data)
+static void rs_free(void *data)
 {
-   rsd_t *rsd = data;
+   rsd_t *rsd = (rsd_t*)data;
 
    rsd_stop(rsd->rd);
    rsd_free(rsd->rd);
+
+   fifo_free(rsd->buffer);
+   slock_free(rsd->cond_lock);
+   scond_free(rsd->cond);
+
    free(rsd);
 }
 
+static size_t rs_write_avail(void *data)
+{
+   rsd_t *rsd = (rsd_t*)data;
+
+   if (rsd->has_error)
+      return 0;
+   rsd_callback_lock(rsd->rd);
+   size_t val = fifo_write_avail(rsd->buffer);
+   rsd_callback_unlock(rsd->rd);
+   return val;
+}
+
+static size_t rs_buffer_size(void *data)
+{
+   (void)data;
+   return 1024 * 4;
+}
+
 const audio_driver_t audio_rsound = {
-   .init = __rsd_init,
-   .write = __rsd_write,
-   .stop = __rsd_stop,
-   .start = __rsd_start,
-   .set_nonblock_state = __rsd_set_nonblock_state,
-   .free = __rsd_free,
-   .ident = "rsound"
+   rs_init,
+   rs_write,
+   rs_stop,
+   rs_start,
+   rs_set_nonblock_state,
+   rs_free,
+   NULL,
+   "rsound",
+   rs_write_avail,
+   rs_buffer_size,
 };
-
-   
-
-
-   
    

audio/sdl_audio.c

@@ -1,69 +1,55 @@
-/*  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.
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
  * 
- *  SSNES is free software: you can redistribute it and/or modify it under the terms
+ *  RetroArch 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;
+ *  RetroArch 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.
+ *  You should have received a copy of the GNU General Public License along with RetroArch.
  *  If not, see <http://www.gnu.org/licenses/>.
  */
 
 
-#include "driver.h"
+#include "../driver.h"
 #include <stdlib.h>
-#include <stdbool.h>
+#include "../boolean.h"
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
 #include "SDL.h"
 #include "SDL_audio.h"
-#include "SDL_thread.h"
-#include "general.h"
-#include "buffer.h"
+#include "../thread.h"
+
+#include "../general.h"
+#include "../fifo_buffer.h"
 
 typedef struct sdl_audio
 {
    bool nonblock;
 
-   SDL_mutex *lock;
-   SDL_cond *cond;
-   rsound_fifo_buffer_t *buffer;
+   slock_t *lock;
+   scond_t *cond;
+   fifo_buffer_t *buffer;
 } sdl_audio_t;
 
 static void sdl_audio_cb(void *data, Uint8 *stream, int len)
 {
-   sdl_audio_t *sdl = data;
+   sdl_audio_t *sdl = (sdl_audio_t*)data;
 
-   size_t avail = rsnd_fifo_read_avail(sdl->buffer);
-   size_t write_size = len > avail ? avail : len;
-   rsnd_fifo_read(sdl->buffer, stream, write_size);
-   SDL_CondSignal(sdl->cond);
+   size_t avail = fifo_read_avail(sdl->buffer);
+   size_t write_size = len > (int)avail ? avail : len;
+   fifo_read(sdl->buffer, stream, write_size);
+   scond_signal(sdl->cond);
 
    // If underrun, fill rest with silence.
    memset(stream + write_size, 0, len - write_size);
 }
 
-// Interesting hack from http://www-graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
-static inline uint32_t next_pow2(uint32_t v)
-{
-   v--;
-   v |= v >> 1;
-   v |= v >> 2;
-   v |= v >> 4;
-   v |= v >> 8;
-   v |= v >> 16;
-   v++;
-   return v;
-}
-
 static inline int find_num_frames(int rate, int latency)
 {
    int frames = (rate * latency) / 1000;
@@ -71,50 +57,49 @@ static inline int find_num_frames(int rate, int latency)
    return next_pow2(frames);
 }
 
-static void* sdl_audio_init(const char* device, int rate, int latency)
+static void *sdl_audio_init(const char *device, unsigned rate, unsigned latency)
 {
    (void)device;
    if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0)
       return NULL;
 
-   sdl_audio_t *sdl = calloc(1, sizeof(*sdl));
+   sdl_audio_t *sdl = (sdl_audio_t*)calloc(1, sizeof(*sdl));
    if (!sdl)
       return NULL;
 
    // We have to buffer up some data ourselves, so we let SDL carry approx half of the latency. SDL double buffers audio and we do as well.
    int frames = find_num_frames(rate, latency / 4);
 
-   SDL_AudioSpec spec = {
-      .freq = rate,
-      .format = AUDIO_S16SYS,
-      .channels = 2,
-      .samples = frames, // This is in audio frames, not samples ... :(
-      .callback = sdl_audio_cb,
-      .userdata = sdl
-   };
+   SDL_AudioSpec spec = {0};
+   spec.freq = rate;
+   spec.format = AUDIO_S16SYS;
+   spec.channels = 2;
+   spec.samples = frames; // This is in audio frames, not samples ... :(
+   spec.callback = sdl_audio_cb;
+   spec.userdata = sdl;
 
    SDL_AudioSpec out;
 
    if (SDL_OpenAudio(&spec, &out) < 0)
    {
-      SSNES_ERR("Failed to open SDL audio: %s\n", SDL_GetError());
+      RARCH_ERR("Failed to open SDL audio: %s\n", SDL_GetError());
       free(sdl);
       return 0;
    }
    g_settings.audio.out_rate = out.freq;
 
-   sdl->lock = SDL_CreateMutex();
-   sdl->cond = SDL_CreateCond();
+   sdl->lock = slock_new();
+   sdl->cond = scond_new();
 
-   SSNES_LOG("SDL audio: Requested %d ms latency, got %d ms\n", latency, (int)(out.samples * 4 * 1000 / g_settings.audio.out_rate));
+   RARCH_LOG("SDL audio: Requested %d ms latency, got %d ms\n", latency, (int)(out.samples * 4 * 1000 / g_settings.audio.out_rate));
 
    // 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);
    }
 
@@ -122,17 +107,17 @@ static void* sdl_audio_init(const char* device, int rate, int latency)
    return sdl;
 }
 
-static ssize_t sdl_audio_write(void* data, const void* buf, size_t size)
+static ssize_t sdl_audio_write(void *data, const void *buf, size_t size)
 {
-   sdl_audio_t *sdl = data;
+   sdl_audio_t *sdl = (sdl_audio_t*)data;
 
    ssize_t ret = 0;
    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;
    }
@@ -142,19 +127,19 @@ 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)
          {
             SDL_UnlockAudio();
-            SDL_mutexP(sdl->lock);
-            SDL_CondWait(sdl->cond, sdl->lock);
-            SDL_mutexV(sdl->lock);
+            slock_lock(sdl->lock);
+            scond_wait(sdl->cond, sdl->lock);
+            slock_unlock(sdl->lock);
          }
          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;
          }
@@ -181,7 +166,7 @@ static bool sdl_audio_start(void *data)
 
 static void sdl_audio_set_nonblock_state(void *data, bool state)
 {
-   sdl_audio_t *sdl = data;
+   sdl_audio_t *sdl = (sdl_audio_t*)data;
    sdl->nonblock = state;
 }
 
@@ -190,28 +175,24 @@ static void sdl_audio_free(void *data)
    SDL_CloseAudio();
    SDL_QuitSubSystem(SDL_INIT_AUDIO);
 
-   sdl_audio_t *sdl = data;
+   sdl_audio_t *sdl = (sdl_audio_t*)data;
    if (sdl)
    {
-      rsnd_fifo_free(sdl->buffer);
-      SDL_DestroyMutex(sdl->lock);
-      SDL_DestroyCond(sdl->cond);
+      fifo_free(sdl->buffer);
+      slock_free(sdl->lock);
+      scond_free(sdl->cond);
    }
    free(sdl);
 }
 
 const audio_driver_t audio_sdl = {
-   .init = sdl_audio_init,
-   .write = sdl_audio_write,
-   .stop = sdl_audio_stop,
-   .start = sdl_audio_start,
-   .set_nonblock_state = sdl_audio_set_nonblock_state,
-   .free = sdl_audio_free,
-   .ident = "sdl"
+   sdl_audio_init,
+   sdl_audio_write,
+   sdl_audio_stop,
+   sdl_audio_start,
+   sdl_audio_set_nonblock_state,
+   sdl_audio_free,
+   NULL,
+   "sdl"
 };
-
-   
-
-
-   
    

audio/sinc.c

@@ -0,0 +1,300 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
+ * 
+ *  RetroArch 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.
+ *
+ *  RetroArch 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 RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// Bog-standard windowed SINC implementation.
+// Only suitable as an upsampler, as there is no low-pass filter stage.
+
+#include "resampler.h"
+#include "../performance.h"
+#include <math.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef RESAMPLER_TEST
+#include "../general.h"
+#else
+#define RARCH_LOG(...)
+#endif
+
+#ifdef __SSE__
+#include <xmmintrin.h>
+#endif
+
+// For the little amount of taps we're using,
+// SSE1 is faster than AVX for some reason.
+// AVX code is kept here though as by increasing number
+// of sinc taps, the AVX code is clearly faster than SSE1.
+#define ENABLE_AVX 0
+
+#if defined(__AVX__) && ENABLE_AVX
+#include <immintrin.h>
+#endif
+
+#define PHASE_BITS 16
+#define SUBPHASE_BITS 10
+#define PHASES (1 << (PHASE_BITS + SUBPHASE_BITS))
+
+#define SIDELOBES 8
+#define TAPS (SIDELOBES * 2)
+#define CUTOFF 0.98
+
+struct rarch_resampler
+{
+   sample_t phase_table[1 << PHASE_BITS][TAPS];
+   sample_t buffer_l[2 * TAPS];
+   sample_t buffer_r[2 * TAPS];
+
+   unsigned ptr;
+   uint32_t time;
+};
+
+static inline double sinc(double val)
+{
+   if (fabs(val) < 0.00001)
+      return 1.0;
+   else
+      return sin(val) / val;
+}
+
+static inline double lanzcos(double index)
+{
+   return sinc(index);
+}
+
+static void init_sinc_table(rarch_resampler_t *resamp)
+{
+   // Sinc phases: [..., p + 3, p + 2, p + 1, p + 0, p - 1, p - 2, p - 3, p - 4, ...]
+   for (int i = 0; i < (1 << PHASE_BITS); i++)
+   {
+      for (int j = 0; j < TAPS; j++)
+      {
+         double p = (double)i / (1 << PHASE_BITS);
+         double sinc_phase = M_PI * (p + (SIDELOBES - 1 - j));
+
+         float val = CUTOFF * sinc(CUTOFF * sinc_phase) * lanzcos(sinc_phase / SIDELOBES);
+         resamp->phase_table[i][j] = val;
+      }
+   }
+}
+
+// No memalign() for us on Win32 ...
+static void *aligned_alloc__(size_t boundary, size_t size)
+{
+   void *ptr = malloc(boundary + size + sizeof(uintptr_t));
+   if (!ptr)
+      return NULL;
+
+   uintptr_t addr = ((uintptr_t)ptr + sizeof(uintptr_t) + boundary) & ~(boundary - 1);
+   void **place   = (void**)addr;
+   place[-1]      = ptr;
+
+   return (void*)addr;
+}
+
+static void aligned_free__(void *ptr)
+{
+   void **p = (void**)ptr;
+   free(p[-1]);
+}
+
+static inline void process_sinc_C(rarch_resampler_t *resamp, float *out_buffer)
+{
+   float sum_l = 0.0f;
+   float sum_r = 0.0f;
+   const float *buffer_l = resamp->buffer_l + resamp->ptr;
+   const float *buffer_r = resamp->buffer_r + resamp->ptr;
+
+   unsigned phase = resamp->time >> SUBPHASE_BITS;
+   const float *phase_table = resamp->phase_table[phase];
+
+   for (unsigned i = 0; i < TAPS; i++)
+   {
+      float sinc_val = phase_table[i];
+      sum_l         += buffer_l[i] * sinc_val;
+      sum_r         += buffer_r[i] * sinc_val;
+   }
+
+   out_buffer[0] = sum_l;
+   out_buffer[1] = sum_r;
+}
+
+#if defined(__AVX__) && ENABLE_AVX
+#define process_sinc_func process_sinc
+static void process_sinc(rarch_resampler_t *resamp, float *out_buffer)
+{
+   __m256 sum_l = _mm256_setzero_ps();
+   __m256 sum_r = _mm256_setzero_ps();
+
+   const float *buffer_l = resamp->buffer_l + resamp->ptr;
+   const float *buffer_r = resamp->buffer_r + resamp->ptr;
+
+   unsigned phase = resamp->time >> SUBPHASE_BITS;
+   const float *phase_table = resamp->phase_table[phase];
+
+   for (unsigned i = 0; i < TAPS; i += 8)
+   {
+      __m256 buf_l = _mm256_loadu_ps(buffer_l + i);
+      __m256 buf_r = _mm256_loadu_ps(buffer_r + i);
+
+      __m256 sinc = _mm256_load_ps(phase_table + i);
+      sum_l       = _mm256_add_ps(sum_l, _mm256_mul_ps(buf_l, sinc));
+      sum_r       = _mm256_add_ps(sum_r, _mm256_mul_ps(buf_r, sinc));
+   }
+
+   // hadd on AVX is weird, and acts on low-lanes and high-lanes separately.
+   __m256 res_l = _mm256_hadd_ps(sum_l, sum_l);
+   __m256 res_r = _mm256_hadd_ps(sum_r, sum_r);
+   res_l = _mm256_hadd_ps(res_l, res_l);
+   res_r = _mm256_hadd_ps(res_r, res_r);
+   res_l = _mm256_add_ps(_mm256_permute2f128_ps(res_l, res_l, 1), res_l);
+   res_r = _mm256_add_ps(_mm256_permute2f128_ps(res_r, res_r, 1), res_r);
+
+   // This is optimized to mov %xmmN, [mem].
+   // There doesn't seem to be any _mm256_store_ss intrinsic.
+   _mm_store_ss(out_buffer + 0, _mm256_extractf128_ps(res_l, 0));
+   _mm_store_ss(out_buffer + 1, _mm256_extractf128_ps(res_r, 0));
+}
+#elif defined(__SSE__)
+#define process_sinc_func process_sinc
+static void process_sinc(rarch_resampler_t *resamp, float *out_buffer)
+{
+   __m128 sum_l = _mm_setzero_ps();
+   __m128 sum_r = _mm_setzero_ps();
+
+   const float *buffer_l = resamp->buffer_l + resamp->ptr;
+   const float *buffer_r = resamp->buffer_r + resamp->ptr;
+
+   unsigned phase = resamp->time >> SUBPHASE_BITS;
+   const float *phase_table = resamp->phase_table[phase];
+
+   for (unsigned i = 0; i < TAPS; i += 4)
+   {
+      __m128 buf_l = _mm_loadu_ps(buffer_l + i);
+      __m128 buf_r = _mm_loadu_ps(buffer_r + i);
+
+      __m128 sinc = _mm_load_ps(phase_table + i);
+      sum_l       = _mm_add_ps(sum_l, _mm_mul_ps(buf_l, sinc));
+      sum_r       = _mm_add_ps(sum_r, _mm_mul_ps(buf_r, sinc));
+   }
+
+   // Them annoying shuffles :V
+   // sum_l = { l3, l2, l1, l0 }
+   // sum_r = { r3, r2, r1, r0 }
+
+   __m128 sum = _mm_add_ps(_mm_shuffle_ps(sum_l, sum_r, _MM_SHUFFLE(1, 0, 1, 0)),
+         _mm_shuffle_ps(sum_l, sum_r, _MM_SHUFFLE(3, 2, 3, 2)));
+
+   // sum   = { r1, r0, l1, l0 } + { r3, r2, l3, l2 }
+   // sum   = { R1, R0, L1, L0 }
+
+   sum = _mm_add_ps(_mm_shuffle_ps(sum, sum, _MM_SHUFFLE(3, 3, 1, 1)), sum);
+
+   // sum   = {R1, R1, L1, L1 } + { R1, R0, L1, L0 }
+   // sum   = { X,  R,  X,  L } 
+
+   // Store L
+   _mm_store_ss(out_buffer + 0, sum);
+
+   // movehl { X, R, X, L } == { X, R, X, R }
+   _mm_store_ss(out_buffer + 1, _mm_movehl_ps(sum, sum));
+}
+#elif defined(HAVE_NEON)
+// Need to make this function pointer as Android doesn't have built-in targets
+// for NEON and plain ARMv7a.
+static void (*process_sinc_func)(rarch_resampler_t *resamp, float *out_buffer);
+
+void process_sinc_neon_asm(float *out, const float *left, const float *right, const float *coeff);
+static void process_sinc_neon(rarch_resampler_t *resamp, float *out_buffer)
+{
+   const float *buffer_l = resamp->buffer_l + resamp->ptr;
+   const float *buffer_r = resamp->buffer_r + resamp->ptr;
+
+   unsigned phase = resamp->time >> SUBPHASE_BITS;
+   const float *phase_table = resamp->phase_table[phase];
+
+   process_sinc_neon_asm(out_buffer, buffer_l, buffer_r, phase_table);
+}
+#else // Plain ol' C99
+#define process_sinc_func process_sinc_C
+#endif
+
+void resampler_process(rarch_resampler_t *re, struct resampler_data *data)
+{
+   // If data->ratio is < 1, we are downsampling.
+   // The sinc table is not set up for this, as it always assumes upsampling.
+   // Downsampling will work, but with some added noise due to aliasing might be present.
+   uint32_t ratio = PHASES / data->ratio;
+
+   const sample_t *input = data->data_in;
+   sample_t *output      = data->data_out;
+   size_t frames         = data->input_frames;
+   size_t out_frames     = 0;
+
+   while (frames)
+   {
+      while (frames && re->time >= PHASES)
+      {
+         re->buffer_l[re->ptr + TAPS] = re->buffer_l[re->ptr] = *input++;
+         re->buffer_r[re->ptr + TAPS] = re->buffer_r[re->ptr] = *input++;
+         re->ptr = (re->ptr + 1) & (TAPS - 1);
+
+         re->time -= PHASES;
+         frames--;
+      }
+
+      while (re->time < PHASES)
+      {
+         process_sinc_func(re, output);
+         output += 2;
+         out_frames++;
+         re->time += ratio;
+      }
+   }
+
+   data->output_frames = out_frames;
+}
+
+void resampler_free(rarch_resampler_t *re)
+{
+   aligned_free__(re);
+}
+
+rarch_resampler_t *resampler_new(void)
+{
+   rarch_resampler_t *re = (rarch_resampler_t*)aligned_alloc__(1024, sizeof(*re));
+   if (!re)
+      return NULL;
+
+   memset(re, 0, sizeof(*re));
+
+   init_sinc_table(re);
+
+#if defined(__AVX__) && ENABLE_AVX
+   RARCH_LOG("Sinc resampler [AVX]\n");
+#elif defined(__SSE__)
+   RARCH_LOG("Sinc resampler [SSE]\n");
+#elif defined(HAVE_NEON)
+   struct rarch_cpu_features cpu;
+   rarch_get_cpu_features(&cpu);
+   process_sinc_func = cpu.simd & RARCH_SIMD_NEON ? process_sinc_neon : process_sinc_C;
+   RARCH_LOG("Sinc resampler [%s]\n", cpu.simd & RARCH_SIMD_NEON ? "NEON" : "C");
+#else
+   RARCH_LOG("Sinc resampler [C]\n");
+#endif
+
+   return re;
+}
+

audio/sinc_neon.S

@@ -0,0 +1,52 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2012 - Hans-Kristian Arntzen
+ * 
+ *  RetroArch 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.
+ *
+ *  RetroArch 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 RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+.arm
+.align 4
+.global process_sinc_neon_asm
+# void process_sinc_neon(float *out, const float *left, const float *right, const float *coeff)
+# Hardcoded to 16 taps.
+process_sinc_neon_asm:
+   # Left
+   vld1.f32 {q0-q1},   [r1]!
+   vld1.f32 {q2-q3},   [r1]!
+   # Right
+   vld1.f32 {q8-q9},   [r2]!
+   vld1.f32 {q10-q11}, [r2]!
+   # Coeff
+   vld1.f32 {q12-q13}, [r3, :128]!
+   vld1.f32 {q14-q15}, [r3, :128]!
+
+   # Left
+   vmul.f32 q0, q0, q12
+   vmul.f32 q1, q1, q13
+   vmla.f32 q0, q2, q14
+   vmla.f32 q1, q3, q15
+
+   # Right
+   vmul.f32 q8, q8, q12
+   vmul.f32 q9, q9, q13
+   vmla.f32 q8, q10, q14
+   vmla.f32 q9, q11, q15
+
+   # Add everything together
+   vadd.f32 q0, q0, q1
+   vadd.f32 q8, q8, q9
+   vadd.f32 d0, d0, d1
+   vadd.f32 d16, d16, d17
+   vpadd.f32 d0, d0, d16
+   vst1.f32 d0, [r0]
+   
+   bx lr

audio/test/Makefile

@@ -0,0 +1,29 @@
+TESTS := test-hermite test-sinc test-snr-sinc test-snr-hermite
+
+CFLAGS += -O3 -g -Wall -pedantic -std=gnu99 -DRESAMPLER_TEST
+LDFLAGS += -lm
+
+all: $(TESTS)
+
+test-hermite: ../hermite.o ../utils.o main.o
+	$(CC) -o $@ $^ $(LDFLAGS)
+
+test-sinc: ../sinc.o ../utils.o main.o
+	$(CC) -o $@ $^ $(LDFLAGS)
+
+test-snr-sinc: ../sinc.o ../utils.o snr.o
+	$(CC) -o $@ $^ $(LDFLAGS)
+
+test-snr-hermite: ../hermite.o ../utils.o snr.o
+	$(CC) -o $@ $^ $(LDFLAGS)
+
+%.o: %.c
+	$(CC) -c -o $@ $< $(CFLAGS)
+
+clean:
+	rm -f $(TESTS)
+	rm -f *.o
+	rm -f ../*.o
+
+.PHONY: clean
+

audio/test/main.c

@@ -0,0 +1,81 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
+ * 
+ *  RetroArch 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.
+ *
+ *  RetroArch 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 RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// Resampler that reads raw S16NE/stereo from stdin and outputs to stdout in S16NE/stereo.
+// Used for testing and performance benchmarking.
+
+#include "../resampler.h"
+#include "../utils.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[])
+{
+   int16_t input_i[1024];
+   int16_t output_i[1024 * 8];
+
+   float input_f[1024];
+   float output_f[1024 * 8];
+
+   if (argc != 3)
+   {
+      fprintf(stderr, "Usage: %s <in-rate> <out-rate> (max ratio: 8.0)\n", argv[0]);
+      return 1;
+   }
+
+   double in_rate = strtod(argv[1], NULL);
+   double out_rate = strtod(argv[2], NULL);
+
+   double ratio = out_rate / in_rate;
+   if (ratio >= 7.99)
+   {
+      fprintf(stderr, "Ratio is too high.\n");
+      return 1;
+   }
+
+   rarch_resampler_t *resamp = resampler_new();
+   if (!resamp)
+   {
+      fprintf(stderr, "Failed to allocate resampler ...\n");
+      return 1;
+   }
+
+   for (;;)
+   {
+      if (fread(input_i, sizeof(int16_t), 1024, stdin) != 1024)
+         break;
+
+      audio_convert_s16_to_float(input_f, input_i, 1024, 1.0f);
+
+      struct resampler_data data = {
+         .data_in = input_f,
+         .data_out = output_f,
+         .input_frames = sizeof(input_f) / (2 * sizeof(float)),
+         .ratio = ratio,
+      };
+
+      resampler_process(resamp, &data);
+
+      size_t output_samples = data.output_frames * 2;
+
+      audio_convert_float_to_s16(output_i, output_f, output_samples);
+
+      if (fwrite(output_i, sizeof(int16_t), output_samples, stdout) != output_samples)
+         break;
+   }
+
+   resampler_free(resamp);
+}
+

audio/test/snr.c

@@ -0,0 +1,315 @@
+/*  RetroArch - A frontend for libretro.
+ *  Copyright (C) 2010-2013 - Hans-Kristian Arntzen
+ * 
+ *  RetroArch 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.
+ *
+ *  RetroArch 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 RetroArch.
+ *  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "../resampler.h"
+#include "../utils.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <complex.h>
+#include <string.h>
+#include <assert.h>
+#include <stdbool.h>
+
+static void gen_signal(float *out, double omega, double bias_samples, size_t samples)
+{
+   for (size_t i = 0; i < samples; i += 2)
+   {
+      out[i + 0] = cos(((i >> 1) + bias_samples) * omega);
+      out[i + 1] = out[i + 0];
+   }
+}
+
+struct snr_result
+{
+   double snr;
+   double gain;
+
+   unsigned alias_freq[3];
+   double alias_power[3];
+};
+
+static unsigned bitrange(unsigned len)
+{
+   unsigned ret = 0;
+   while ((len >>= 1))
+      ret++;
+
+   return ret;
+}
+
+static unsigned bitswap(unsigned i, unsigned range)
+{
+   unsigned ret = 0;
+   for (unsigned shifts = 0; shifts < range; shifts++)
+      ret |= i & (1 << (range - shifts - 1)) ? (1 << shifts) : 0;
+
+   return ret;
+}
+
+// When interleaving the butterfly buffer, addressing puts bits in reverse.
+// [0, 1, 2, 3, 4, 5, 6, 7] => [0, 4, 2, 6, 1, 5, 3, 7] 
+static void interleave(complex double *butterfly_buf, size_t samples)
+{
+   unsigned range = bitrange(samples);
+   for (unsigned i = 0; i < samples; i++)
+   {
+      unsigned target = bitswap(i, range);
+      if (target > i)
+      {
+         complex double tmp = butterfly_buf[target];
+         butterfly_buf[target] = butterfly_buf[i];
+         butterfly_buf[i] = tmp;
+      }
+   }
+}
+
+static complex double gen_phase(double index)
+{
+   return cexp(M_PI * I * index);
+}
+
+static void butterfly(complex double *a, complex double *b, complex double mod)
+{
+   mod *= *b;
+   complex double a_ = *a + mod;
+   complex double b_ = *a - mod;
+   *a = a_;
+   *b = b_;
+}
+
+static void butterflies(complex double *butterfly_buf, double phase_dir, size_t step_size, size_t samples)
+{
+   for (unsigned i = 0; i < samples; i += 2 * step_size)
+      for (unsigned j = i; j < i + step_size; j++)
+         butterfly(&butterfly_buf[j], &butterfly_buf[j + step_size], gen_phase((phase_dir * (j - i)) / step_size));
+}
+
+static void calculate_fft(const float *data, complex double *butterfly_buf, size_t samples)
+{
+   // Enforce POT.
+   assert((samples & (samples - 1)) == 0);
+
+   for (unsigned i = 0; i < samples; i++)
+      butterfly_buf[i] = data[2 * i];
+
+   // Interleave buffer to work with FFT.
+   interleave(butterfly_buf, samples);
+
+   // Fly, lovely butterflies! :D
+   for (unsigned step_size = 1; step_size < samples; step_size *= 2)
+      butterflies(butterfly_buf, -1.0, step_size, samples);
+}
+
+static void calculate_fft_adjust(complex double *butterfly_buf, double gain, bool merge_high, size_t samples)
+{
+   if (merge_high)
+   {
+      for (unsigned i = 1; i < samples / 2; i++)
+         butterfly_buf[i] *= 2.0;
+   }
+
+   // Normalize amplitudes.
+   for (unsigned i = 0; i < samples; i++)
+      butterfly_buf[i] *= gain;
+}
+
+static void calculate_ifft(complex double *butterfly_buf, size_t samples, bool normalize)
+{
+   // Enforce POT.
+   assert((samples & (samples - 1)) == 0);
+
+   interleave(butterfly_buf, samples);
+
+   // Fly, lovely butterflies! In opposite direction! :D
+   for (unsigned step_size = 1; step_size < samples; step_size *= 2)
+      butterflies(butterfly_buf, 1.0, step_size, samples);
+
+   if (normalize)
+      calculate_fft_adjust(butterfly_buf, 1.0 / samples, false, samples);
+}
+
+static void test_fft(void)
+{
+   fprintf(stderr, "Sanity checking FFT ...\n");
+   float signal[32];
+   complex double butterfly_buf[16];
+   complex double buf_tmp[16];
+
+   const float cos_freqs[] = {
+      1.0, 4.0, 6.0,
+   };
+
+   const float sin_freqs[] = {
+      -2.0, 5.0, 7.0,
+   };
+
+   for (unsigned i = 0; i < 16; i++)
+   {
+      signal[2 * i] = 0.0;
+      for (unsigned j = 0; j < sizeof(cos_freqs) / sizeof(cos_freqs[0]); j++)
+         signal[2 * i] += cos(2.0 * M_PI * i * cos_freqs[j] / 16.0);
+      for (unsigned j = 0; j < sizeof(sin_freqs) / sizeof(sin_freqs[0]); j++)
+         signal[2 * i] += sin(2.0 * M_PI * i * sin_freqs[j] / 16.0);
+   }
+
+   calculate_fft(signal, butterfly_buf, 16);
+   memcpy(buf_tmp, butterfly_buf, sizeof(buf_tmp));
+   calculate_fft_adjust(buf_tmp, 1.0 / 16, true, 16);
+
+   fprintf(stderr, "FFT: { ");
+   for (unsigned i = 0; i < 7; i++)
+      fprintf(stderr, "(%4.2lf, %4.2lf), ", creal(buf_tmp[i]), cimag(buf_tmp[i]));
+   fprintf(stderr, "(%4.2lf, %4.2lf) }\n", creal(buf_tmp[7]), cimag(buf_tmp[7]));
+
+   calculate_ifft(butterfly_buf, 16, true);
+
+   fprintf(stderr, "Original:    { ");
+   for (unsigned i = 0; i < 15; i++)
+      fprintf(stderr, "%5.2f, ", signal[2 * i]);
+   fprintf(stderr, "%5.2f }\n", signal[2 * 15]);
+
+   fprintf(stderr, "FFT => IFFT: { ");
+   for (unsigned i = 0; i < 15; i++)
+      fprintf(stderr, "%5.2lf, ", creal(butterfly_buf[i]));
+   fprintf(stderr, "%5.2lf }\n", creal(butterfly_buf[15]));
+}
+
+static void set_alias_power(struct snr_result *res, unsigned freq, double power)
+{
+   for (unsigned i = 0; i < 3; i++)
+   {
+      if (power >= res->alias_power[i])
+      {
+         memmove(res->alias_freq + i + 1, res->alias_freq + i, (2 - i) * sizeof(res->alias_freq[0]));
+         memmove(res->alias_power + i + 1, res->alias_power + i, (2 - i) * sizeof(res->alias_power[0]));
+         res->alias_power[i] = power;
+         res->alias_freq[i] = freq;
+         break;
+      }
+   }
+}
+
+static void calculate_snr(struct snr_result *res,
+      unsigned in_rate, unsigned max_rate,
+      const float *resamp, complex double *butterfly_buf, size_t samples)
+{
+   samples >>= 1;
+   calculate_fft(resamp, butterfly_buf, samples);
+   calculate_fft_adjust(butterfly_buf, 1.0 / samples, true, samples);
+
+   memset(res, 0, sizeof(*res));
+
+   double signal = cabs(butterfly_buf[in_rate] * butterfly_buf[in_rate]);
+   butterfly_buf[in_rate] = 0.0;
+
+   double noise = 0.0;
+
+   // Aliased frequencies above half the original sampling rate are not considered.
+   for (unsigned i = 0; i <= max_rate; i++)
+   {
+      double power = cabs(butterfly_buf[i] * butterfly_buf[i]);
+      set_alias_power(res, i, power);
+      noise += power;
+   }
+
+   res->snr = 10.0 * log10(signal / noise);
+   res->gain = 10.0 * log10(signal);
+
+   for (unsigned i = 0; i < 3; i++)
+      res->alias_power[i] = 10.0 * log10(res->alias_power[i]);
+}
+
+int main(int argc, char *argv[])
+{
+   if (argc != 2)
+   {
+      fprintf(stderr, "Usage: %s <ratio> (out-rate is fixed for FFT).\n", argv[0]);
+      return 1;
+   }
+
+   double ratio = strtod(argv[1], NULL);
+
+   const unsigned fft_samples = 1024 * 128;
+   unsigned out_rate = fft_samples / 2;
+   unsigned in_rate = out_rate / ratio;
+   ratio = (double)out_rate / in_rate;
+
+   if (ratio <= 1.0)
+   {
+      fprintf(stderr, "Ratio too low ...\n");
+      return 1;
+   }
+
+   static const float freq_list[] = {
+      0.001, 0.002, 0.003, 0.004, 0.005, 0.006, 0.007, 0.008, 0.009,
+      0.010, 0.015, 0.020, 0.025, 0.030, 0.035, 0.040, 0.045, 0.050,
+      0.060, 0.070, 0.080, 0.090,
+      0.10, 0.15, 0.20, 0.25, 0.30, 0.35,
+      0.40, 0.41, 0.42, 0.43, 0.44, 0.45,
+      0.46, 0.47, 0.48, 0.49,
+      0.495, 0.496, 0.497, 0.498, 0.499,
+   };
+
+   unsigned samples = in_rate * 4;
+   float *input = calloc(sizeof(float), samples);
+   float *output = calloc(sizeof(float), (fft_samples + 1) * 2);
+   complex double *butterfly_buf = calloc(sizeof(complex double), fft_samples / 2);
+   assert(input);
+   assert(output);
+
+   rarch_resampler_t *re = resampler_new();
+   assert(re);
+
+   test_fft();
+
+   printf("Omega,SNR,Gain\n");
+   for (unsigned i = 0; i < sizeof(freq_list) / sizeof(freq_list[0]); i++)
+   {
+      unsigned freq = freq_list[i] * in_rate;
+      double omega = 2.0 * M_PI * freq / in_rate;
+      gen_signal(input, omega, 0, samples);
+
+      struct resampler_data data = {
+         .data_in = input,
+         .data_out = output,
+         .input_frames = in_rate * 2,
+         .ratio = ratio,
+      };
+
+      resampler_process(re, &data);
+
+      unsigned out_samples = data.output_frames * 2;
+      assert(out_samples >= fft_samples * 2);
+
+      // We generate 2 seconds worth of audio, however, only the last second is considered so phase has stabilized.
+      struct snr_result res;
+      calculate_snr(&res, freq, in_rate / 2, output + fft_samples, butterfly_buf, fft_samples);
+
+      printf("SNR @ w = %5.3f : %6.2lf dB, Gain: %6.1lf dB\n",
+            freq_list[i], res.snr, res.gain);
+
+      printf("\tAliases: #1 (w = %5.3f, %6.2lf dB), #2 (w = %5.3f, %6.2lf dB), #3 (w = %5.3f, %6.2lf dB)\n",
+            res.alias_freq[0] / (float)in_rate, res.alias_power[0],
+            res.alias_freq[1] / (float)in_rate, res.alias_power[1],
+            res.alias_freq[2] / (float)in_rate, res.alias_power[2]);
+   }
+
+   resampler_free(re);
+   free(input);
+   free(output);
+   free(butterfly_buf);
+}
+