Merge branch 'master' into vertex-loader-cleanup

Conflicts: Source/Core/Common/Src/CommonFuncs.h Source/Core/VideoCommon/Src/VertexLoader.cpp
2026-06-19 01:16:48 -07:00 · 2013-03-04 15:47:56 -06:00
parent bf58c70e9b 0041ec618c
commit f3f89e1d00
289 changed files with 11758 additions and 2519 deletions
@@ -106,9 +106,22 @@ if(DOLPHIN_IS_STABLE)
 else()
 	set(DOLPHIN_VERSION_PATCH ${DOLPHIN_WC_REVISION})
 endif()
+message(${CMAKE_SYSTEM_PROCESSOR})
+if(${CMAKE_SYSTEM_PROCESSOR} MATCHES "^arm")
+	set(_M_GENERIC 1)
+	set(_M_ARM 1)
+	add_definitions(-marm -march=armv7-a)
+	add_definitions(-D_M_ARM=1)
+	add_definitions(-D_M_GENERIC=1)
+endif()

+# Set these next two lines to test generic
+#set(_M_GENERIC 1)
+#add_definitions(-D_M_GENERIC=1)
 # Various compile flags
-add_definitions(-msse2)
+if(NOT _M_GENERIC)
+	add_definitions(-msse2)
+endif()

 include(CheckCXXCompilerFlag)
 macro(check_and_add_flag var flag)
@@ -258,135 +271,141 @@ if(USE_EGL)
 endif()
 add_definitions(-D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE)

+option(ANDROID "Enables a build for Android" OFF)
+if(ANDROID)
+	message("Building for Android")
+	add_definitions(-DANDROID)
+endif()
 ########################################
 # Dependency checking
 #
 # TODO: We should have options for dependencies included in the externals to
 # override autodetection of system libraries and force the usage of the
 # externals.
+if(NOT ANDROID)
+	include(CheckLib)

-include(CheckLib)
-
-include(FindOpenGL)
-include_directories(${OPENGL_INCLUDE_DIR})
-if(NOT OPENGL_GLU_FOUND)
-	message(FATAL_ERROR "GLU is required but not found")
-endif()
-
-if(OPENMP)
-	include(FindOpenMP OPTIONAL)
-	if(OPENMP_FOUND)
-		message("OpenMP parallelization enabled")
-		add_definitions("${OpenMP_CXX_FLAGS}")
-		set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OpenMP_CXX_FLAGS}")
+	include(FindOpenGL)
+	include_directories(${OPENGL_INCLUDE_DIR})
+	if(NOT OPENGL_GLU_FOUND)
+		message(FATAL_ERROR "GLU is required but not found")
 	endif()
-endif()
-if(NOT OPENMP_FOUND)
-	add_definitions(-Wno-unknown-pragmas)
-	message("OpenMP parallelization disabled")
-endif()

-include(FindALSA OPTIONAL)
-if(ALSA_FOUND)
-	add_definitions(-DHAVE_ALSA=1)
-	message("ALSA found, enabling ALSA sound backend")
-else()
-	add_definitions(-DHAVE_ALSA=0)
-	message("ALSA NOT found, disabling ALSA sound backend")
-endif(ALSA_FOUND)
+	if(OPENMP)
+		include(FindOpenMP OPTIONAL)
+		if(OPENMP_FOUND)
+			message("OpenMP parallelization enabled")
+			add_definitions("${OpenMP_CXX_FLAGS}")
+			set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OpenMP_CXX_FLAGS}")
+		endif()
+	endif()
+	if(NOT OPENMP_FOUND)
+		add_definitions(-Wno-unknown-pragmas)
+		message("OpenMP parallelization disabled")
+	endif()

-check_lib(AO ao QUIET)
-if(AO_FOUND)
-	add_definitions(-DHAVE_AO=1)
-	message("ao found, enabling ao sound backend")
-else()
-	add_definitions(-DHAVE_AO=0)
-	message("ao NOT found, disabling ao sound backend")
-endif(AO_FOUND)
+	include(FindALSA OPTIONAL)
+	if(ALSA_FOUND)
+		add_definitions(-DHAVE_ALSA=1)
+		message("ALSA found, enabling ALSA sound backend")
+	else()
+		add_definitions(-DHAVE_ALSA=0)
+		message("ALSA NOT found, disabling ALSA sound backend")
+	endif(ALSA_FOUND)

-check_lib(BLUEZ bluez QUIET)
-if(BLUEZ_FOUND)
-	add_definitions(-DHAVE_BLUEZ=1)
-	message("bluez found, enabling bluetooth support")
-else()
-	add_definitions(-DHAVE_BLUEZ=0)
-	message("bluez NOT found, disabling bluetooth support")
-endif(BLUEZ_FOUND)
+	check_lib(AO ao QUIET)
+	if(AO_FOUND)
+		add_definitions(-DHAVE_AO=1)
+		message("ao found, enabling ao sound backend")
+	else()
+		add_definitions(-DHAVE_AO=0)
+		message("ao NOT found, disabling ao sound backend")
+	endif(AO_FOUND)

-check_lib(PULSEAUDIO libpulse-simple QUIET)
-if(PULSEAUDIO_FOUND)
-	add_definitions(-DHAVE_PULSEAUDIO=1)
-	message("PulseAudio found, enabling PulseAudio sound backend")
-else()
-	add_definitions(-DHAVE_PULSEAUDIO=0)
-	message("PulseAudio NOT found, disabling PulseAudio sound backend")
-endif(PULSEAUDIO_FOUND)
+	check_lib(BLUEZ bluez QUIET)
+	if(BLUEZ_FOUND)
+		add_definitions(-DHAVE_BLUEZ=1)
+		message("bluez found, enabling bluetooth support")
+	else()
+		add_definitions(-DHAVE_BLUEZ=0)
+		message("bluez NOT found, disabling bluetooth support")
+	endif(BLUEZ_FOUND)

-include(FindOpenAL OPTIONAL)
-if(OPENAL_FOUND)
-	add_definitions(-DHAVE_OPENAL=1)
-	include_directories(${OPENAL_INCLUDE_DIR})
-	message("OpenAL found, enabling OpenAL sound backend")
-else()
-	add_definitions(-DHAVE_OPENAL=0)
-	message("OpenAL NOT found, disabling OpenAL sound backend")
-endif(OPENAL_FOUND)
+	check_lib(PULSEAUDIO libpulse-simple QUIET)
+	if(PULSEAUDIO_FOUND)
+		add_definitions(-DHAVE_PULSEAUDIO=1)
+		message("PulseAudio found, enabling PulseAudio sound backend")
+	else()
+		add_definitions(-DHAVE_PULSEAUDIO=0)
+		message("PulseAudio NOT found, disabling PulseAudio sound backend")
+	endif(PULSEAUDIO_FOUND)
+
+	include(FindOpenAL OPTIONAL)
+	if(OPENAL_FOUND)
+		add_definitions(-DHAVE_OPENAL=1)
+		include_directories(${OPENAL_INCLUDE_DIR})
+		message("OpenAL found, enabling OpenAL sound backend")
+	else()
+		add_definitions(-DHAVE_OPENAL=0)
+		message("OpenAL NOT found, disabling OpenAL sound backend")
+	endif(OPENAL_FOUND)

 # Note: We do not need to explicitly check for X11 as it is done in the cmake
 # FindOpenGL module on linux.
-if(UNIX AND NOT APPLE)
+	if(UNIX AND NOT APPLE)
+		if(X11_FOUND)
+			add_definitions(-DHAVE_X11=1)
+			include_directories(${X11_INCLUDE_DIR})
+			message("X11 found")
+		else()
+			message(FATAL_ERROR "X11 is required but not found")
+		endif(X11_FOUND)
+	else()
+		add_definitions(-DHAVE_X11=0)
+	endif()
+
 	if(X11_FOUND)
-		add_definitions(-DHAVE_X11=1)
-		include_directories(${X11_INCLUDE_DIR})
-		message("X11 found")
+		check_lib(XRANDR Xrandr)
+	endif()
+	if(XRANDR_FOUND)
+		add_definitions(-DHAVE_XRANDR=1)
 	else()
-		message(FATAL_ERROR "X11 is required but not found")
-	endif(X11_FOUND)
-else()
-	add_definitions(-DHAVE_X11=0)
-endif()
+		add_definitions(-DHAVE_XRANDR=0)
+	endif(XRANDR_FOUND)

-if(X11_FOUND)
-	check_lib(XRANDR Xrandr)
-endif()
-if(XRANDR_FOUND)
-	add_definitions(-DHAVE_XRANDR=1)
-else()
-	add_definitions(-DHAVE_XRANDR=0)
-endif(XRANDR_FOUND)
+	if(ENCODE_FRAMEDUMPS)
+		check_libav()
+	endif()

-if(ENCODE_FRAMEDUMPS)
-	check_libav()
-endif()
-
-include(CheckCXXSourceRuns)
-set(CMAKE_REQUIRED_LIBRARIES portaudio)
-CHECK_CXX_SOURCE_RUNS(
-	"#include <portaudio.h>
-	int main(int argc, char **argv)
-	{ if(Pa_GetVersion() >= 1890) return 0; else return 1; }"
-	PORTAUDIO)
-if(PORTAUDIO)
-	message("PortAudio found, enabling mic support")
-	add_definitions(-DHAVE_PORTAUDIO=1)
-	set(PORTAUDIO_FOUND TRUE)
-else()
-	message("PortAudio not found, disabling mic support")
-	add_definitions(-DHAVE_PORTAUDIO=0)
-	set(PORTAUDIO_FOUND FALSE)
-endif(PORTAUDIO)
-
-if(OPROFILING)
-	check_lib(OPROFILE opagent opagent.h)
-	check_lib(BFD bfd bfd.h)
-	if(OPROFILE_FOUND AND BFD_FOUND)
-		message("oprofile found, enabling profiling support")
-		add_definitions(-DUSE_OPROFILE=1)
+	include(CheckCXXSourceRuns)
+	set(CMAKE_REQUIRED_LIBRARIES portaudio)
+	CHECK_CXX_SOURCE_RUNS(
+		"#include <portaudio.h>
+		int main(int argc, char **argv)
+		{ if(Pa_GetVersion() >= 1890) return 0; else return 1; }"
+		PORTAUDIO)
+	if(PORTAUDIO)
+		message("PortAudio found, enabling mic support")
+		add_definitions(-DHAVE_PORTAUDIO=1)
+		set(PORTAUDIO_FOUND TRUE)
 	else()
-		message(FATAL_ERROR "oprofile or bfd not found. Can't build profiling support.")
+		message("PortAudio not found, disabling mic support")
+		add_definitions(-DHAVE_PORTAUDIO=0)
+		set(PORTAUDIO_FOUND FALSE)
+	endif(PORTAUDIO)
+
+	option(OPROFILING "Enable profiling" OFF)
+	if(OPROFILING)
+		check_lib(OPROFILE opagent opagent.h)
+		check_lib(BFD bfd bfd.h)
+		if(OPROFILE_FOUND AND BFD_FOUND)
+			message("oprofile found, enabling profiling support")
+			add_definitions(-DUSE_OPROFILE=1)
+		else()
+			message(FATAL_ERROR "oprofile or bfd not found. Can't build profiling support.")
+		endif()
 	endif()
 endif()
-
 ########################################
 # Setup include directories (and make sure they are preferred over the Externals)
 #
@@ -401,7 +420,6 @@ include_directories(Source/Core/InputCommon/Src)
 include_directories(Source/Core/VideoCommon/Src)
 include_directories(Source/Core/VideoUICommon/Src)

-
 ########################################
 # Process externals and setup their include directories
 #
@@ -415,7 +433,7 @@ include_directories(Source/Core/VideoUICommon/Src)
 add_subdirectory(Externals/Bochs_disasm)
 include_directories(Externals/Bochs_disasm)

-if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin" AND NOT ANDROID)
 	check_lib(LZO lzo2 lzo/lzo1x.h QUIET)
 endif()
 if(LZO_FOUND)
@@ -440,15 +458,16 @@ if(OPENAL_FOUND)
 	endif()
 endif()

-if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-	include(FindSDL2 OPTIONAL)
-endif()
-if(SDL2_FOUND)
-	message("Using shared SDL2")
-	include_directories(${SDL2_INCLUDE_DIR})
-else(SDL2_FOUND)
-	# SDL2 not found, try SDL
+if(NOT ANDROID)
 	if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+		include(FindSDL2 OPTIONAL)
+	endif()
+	if(SDL2_FOUND)
+		message("Using shared SDL2")
+		include_directories(${SDL2_INCLUDE_DIR})
+	else(SDL2_FOUND)
+		# SDL2 not found, try SDL
+		if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 		include(FindSDL OPTIONAL)
 	endif()
 	if(SDL_FOUND)
@@ -460,12 +479,13 @@ else(SDL2_FOUND)
 		include_directories(Externals/SDL/SDL Externals/SDL Externals/SDL/include)
 		add_subdirectory(Externals/SDL)
 	endif(SDL_FOUND)
-endif(SDL2_FOUND)
+	endif(SDL2_FOUND)
+endif()

 set(SFML_FIND_VERSION TRUE)
 set(SFML_FIND_VERSION_MAJOR 1)
 set(SFML_FIND_VERSION_MINOR 5)
-if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin" AND NOT ANDROID)
 	include(FindSFML OPTIONAL)
 endif()
 if(SFML_FOUND AND NOT SFML_VERSION_MAJOR) # SFML 1.x doesn't define SFML_VERSION_MAJOR
@@ -476,7 +496,7 @@ else()
       include_directories(Externals/SFML/include)
 endif()

-if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin" AND NOT ANDROID)
 	check_lib(SOIL SOIL SOIL/SOIL.h QUIET)
 endif()
 if(SOIL_FOUND)
@@ -506,26 +526,19 @@ if(WIN32)
 	find_library(GLEW glew32s PATHS Externals/GLew)
 	include_directories(Externals/GLew/include)
 else()
-	if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-		check_lib(GLEW GLEW GL/glew.h)
+	if(NOT ANDROID)
+		if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+			check_lib(GLEW GLEW GL/glew.h)
+		endif()
+		if(NOT GLEW_FOUND)
+			message("Using static GLEW from Externals")
+			add_subdirectory(Externals/GLew)
+			include_directories(Externals/GLew/include)
+		endif(NOT GLEW_FOUND)
 	endif()
-	if(NOT GLEW_FOUND)
-		message("Using static GLEW from Externals")
-		add_subdirectory(Externals/GLew)
-		include_directories(Externals/GLew/include)
-	endif(NOT GLEW_FOUND)
-
-	if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-		check_lib(CG Cg Cg/cg.h)
-	endif()
-	if(NOT CG_FOUND)
-		message("Using static Cg from Externals")
-		include_directories(Externals)
-	endif(NOT CG_FOUND)
-	check_lib(CGGL CgGL Cg/cgGL.h)
 endif()

-if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin" AND NOT ANDROID)
 	find_library(CL OpenCL)
 	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-weak_framework,OpenCL")
 else()
@@ -533,10 +546,25 @@ else()
 	add_subdirectory(Externals/CLRun)
 endif()

-if(NOT DISABLE_WX)
+if(NOT DISABLE_WX AND NOT ANDROID)
 	include(FindwxWidgets OPTIONAL)
 	FIND_PACKAGE(wxWidgets COMPONENTS core aui adv)

+	if(wxWidgets_FOUND)
+		EXECUTE_PROCESS(
+			COMMAND sh "${wxWidgets_CONFIG_EXECUTABLE}"
+				${wxWidgets_CONFIG_OPTIONS} --version
+			OUTPUT_VARIABLE wxWidgets_VERSION
+			OUTPUT_STRIP_TRAILING_WHITESPACE
+			ERROR_QUIET
+			)
+		message("Found wxWidgets version ${wxWidgets_VERSION}")
+		if(${wxWidgets_VERSION} VERSION_LESS "2.8.9")
+			message("At least 2.8.9 is required; ignoring found version")
+			unset(wxWidgets_FOUND)
+		endif()
+	endif(wxWidgets_FOUND)
+		
 	if(wxWidgets_FOUND)
 		EXECUTE_PROCESS(
 			COMMAND sh "${wxWidgets_CONFIG_EXECUTABLE}"
@@ -557,26 +585,26 @@ if(NOT DISABLE_WX)
 		endif()
 	endif(wxWidgets_FOUND)

-	if(UNIX AND NOT APPLE)
-		# There is a bug in the FindGTK module in cmake version 2.8.2 that
-		# does not find gdk-pixbuf-2.0.  On the other hand some 2.8.3
-		# users have complained that pkg-config does not find
-		# gdk-pixbuf-2.0.  On yet another hand, cmake version 2.8.3 in
-		# Ubuntu Natty does not find the glib libraries correctly.
-		# Ugly!!!
-		execute_process(COMMAND lsb_release -c -s
-			OUTPUT_VARIABLE DIST_NAME
-			ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
-		if(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION}
-				VERSION_EQUAL 2.8.2 OR "${DIST_NAME}" STREQUAL "natty")
-			check_lib(GTK2 gtk+-2.0 gtk.h REQUIRED)
-		else()
-			include(FindGTK2)
-			if(GTK2_FOUND)
-				include_directories(${GTK2_INCLUDE_DIRS})
+		if(UNIX AND NOT APPLE)
+			# There is a bug in the FindGTK module in cmake version 2.8.2 that
+			# does not find gdk-pixbuf-2.0.  On the other hand some 2.8.3
+			# users have complained that pkg-config does not find
+			# gdk-pixbuf-2.0.  On yet another hand, cmake version 2.8.3 in
+			# Ubuntu Natty does not find the glib libraries correctly.
+			# Ugly!!!
+			execute_process(COMMAND lsb_release -c -s
+				OUTPUT_VARIABLE DIST_NAME
+				ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+			if(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION}
+					VERSION_EQUAL 2.8.2 OR "${DIST_NAME}" STREQUAL "natty")
+				check_lib(GTK2 gtk+-2.0 gtk.h REQUIRED)
+			else()
+				include(FindGTK2)
+				if(GTK2_FOUND)
+					include_directories(${GTK2_INCLUDE_DIRS})
+				endif()
 			endif()
 		endif()
-	endif()

 	if(wxWidgets_FOUND)
 		include(${wxWidgets_USE_FILE})
@@ -608,7 +636,7 @@ if(NOT DISABLE_WX)
 		set(wxWidgets_LIBRARIES "wx")
 	endif(wxWidgets_FOUND)
 	add_definitions(-DHAVE_WX=1)
-endif(NOT DISABLE_WX)
+endif(NOT DISABLE_WX AND NOT ANDROID)


 ########################################
@@ -682,4 +710,4 @@ list(APPEND CPACK_SOURCE_IGNORE_FILES "${CMAKE_BINARY_DIR}")

 # CPack must be included after the CPACK_* variables are set in order for those
 # variables to take effect.
-include(CPack)
+Include(CPack)
@@ -6,6 +6,11 @@ set(SRCS	Src/AudioCommon.cpp

 set(LIBS "")

+if(ANDROID)
+	set(SRCS ${SRCS} Src/OpenSLESStream.cpp)
+	set(LIBS ${LIBS} OpenSLES)
+endif(ANDROID)
+
 if(ALSA_FOUND)
 	set(SRCS ${SRCS} Src/AlsaSoundStream.cpp)
 	set(LIBS ${LIBS} ${ALSA_LIBRARIES})
@@ -26,6 +26,7 @@
 #include "CoreAudioSoundStream.h"
 #include "OpenALStream.h"
 #include "PulseAudioStream.h"
+#include "OpenSLESStream.h"
 #include "../../Core/Src/Movie.h"
 #include "../../Core/Src/ConfigManager.h"

@@ -55,7 +56,8 @@ namespace AudioCommon
 			soundStream = new CoreAudioSound(mixer);
 		else if (backend == BACKEND_PULSEAUDIO  && PulseAudio::isValid())
 			soundStream = new PulseAudio(mixer);
-
+		else if (backend == BACKEND_OPENSLES && OpenSLESStream::isValid())
+			soundStream = new OpenSLESStream(mixer);
 		if (soundStream != NULL)
 		{
 			UpdateSoundStream();
@@ -116,7 +118,8 @@ namespace AudioCommon
 			backends.push_back(BACKEND_PULSEAUDIO);
 		if (OpenALStream::isValid())
 			backends.push_back(BACKEND_OPENAL);
-	   
+		if (OpenSLESStream::isValid())
+			backends.push_back(BACKEND_OPENSLES);
 		return backends;
 	}

@@ -0,0 +1,145 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program 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 Foundation, version 2.0.
+
+// This program 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 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+
+#ifdef ANDROID
+#include "Common.h"
+#include <assert.h>
+#include "OpenSLESStream.h"
+
+#include <SLES/OpenSLES.h>
+#include <SLES/OpenSLES_Android.h>
+
+// engine interfaces
+static SLObjectItf engineObject;
+static SLEngineItf engineEngine;
+static SLObjectItf outputMixObject;
+
+// buffer queue player interfaces
+static SLObjectItf bqPlayerObject = NULL;
+static SLPlayItf bqPlayerPlay;
+static SLAndroidSimpleBufferQueueItf bqPlayerBufferQueue;
+static SLMuteSoloItf bqPlayerMuteSolo;
+static SLVolumeItf bqPlayerVolume;
+static CMixer *g_mixer; 
+#define BUFFER_SIZE 512
+#define BUFFER_SIZE_IN_SAMPLES (BUFFER_SIZE / 2)
+
+// Double buffering.
+static short buffer[2][BUFFER_SIZE];
+static int curBuffer = 0;
+
+static void bqPlayerCallback(SLAndroidSimpleBufferQueueItf bq, void *context) {
+	assert(bq == bqPlayerBufferQueue);
+	assert(NULL == context);
+
+	short *nextBuffer = buffer[curBuffer];
+	int nextSize = sizeof(buffer[0]);
+
+	SLresult result = (*bqPlayerBufferQueue)->Enqueue(bqPlayerBufferQueue, nextBuffer, nextSize);
+
+	// Comment from sample code:
+	// the most likely other result is SL_RESULT_BUFFER_INSUFFICIENT,
+	// which for this code example would indicate a programming error
+	assert(SL_RESULT_SUCCESS == result);
+
+	curBuffer ^= 1;	// Switch buffer
+	// Render to the fresh buffer
+	g_mixer->Mix(reinterpret_cast<short *>(buffer[curBuffer]), BUFFER_SIZE_IN_SAMPLES);
+}
+bool OpenSLESStream::Start()
+{
+	SLresult result;
+	// create engine
+	result = slCreateEngine(&engineObject, 0, NULL, 0, NULL, NULL);
+	assert(SL_RESULT_SUCCESS == result);
+	result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE);
+	assert(SL_RESULT_SUCCESS == result);
+	result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine);
+	assert(SL_RESULT_SUCCESS == result);
+	result = (*engineEngine)->CreateOutputMix(engineEngine, &outputMixObject, 0, 0, 0);
+	assert(SL_RESULT_SUCCESS == result);
+	result = (*outputMixObject)->Realize(outputMixObject, SL_BOOLEAN_FALSE);
+	assert(SL_RESULT_SUCCESS == result);
+
+	SLDataLocator_AndroidSimpleBufferQueue loc_bufq = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2};
+	SLDataFormat_PCM format_pcm = {
+		SL_DATAFORMAT_PCM,
+		2,
+		SL_SAMPLINGRATE_44_1,
+		SL_PCMSAMPLEFORMAT_FIXED_16,
+		SL_PCMSAMPLEFORMAT_FIXED_16,
+		SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT,
+		SL_BYTEORDER_LITTLEENDIAN
+	};
+
+	SLDataSource audioSrc = {&loc_bufq, &format_pcm};
+
+	// configure audio sink
+	SLDataLocator_OutputMix loc_outmix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject};
+	SLDataSink audioSnk = {&loc_outmix, NULL};
+
+	// create audio player
+	const SLInterfaceID ids[2] = {SL_IID_BUFFERQUEUE, SL_IID_VOLUME};
+	const SLboolean req[2] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE};
+	result = (*engineEngine)->CreateAudioPlayer(engineEngine, &bqPlayerObject, &audioSrc, &audioSnk, 2, ids, req);
+	assert(SL_RESULT_SUCCESS == result);
+
+	result = (*bqPlayerObject)->Realize(bqPlayerObject, SL_BOOLEAN_FALSE);
+	assert(SL_RESULT_SUCCESS == result);
+	result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_PLAY, &bqPlayerPlay);
+	assert(SL_RESULT_SUCCESS == result);
+	result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_BUFFERQUEUE,
+		&bqPlayerBufferQueue);
+	assert(SL_RESULT_SUCCESS == result);
+	result = (*bqPlayerBufferQueue)->RegisterCallback(bqPlayerBufferQueue, bqPlayerCallback, NULL);
+	assert(SL_RESULT_SUCCESS == result);
+	result = (*bqPlayerPlay)->SetPlayState(bqPlayerPlay, SL_PLAYSTATE_PLAYING);
+	assert(SL_RESULT_SUCCESS == result);
+
+	// Render and enqueue a first buffer. (or should we just play the buffer empty?)
+	curBuffer = 0;
+
+	result = (*bqPlayerBufferQueue)->Enqueue(bqPlayerBufferQueue, buffer[curBuffer], sizeof(buffer[curBuffer]));
+	if (SL_RESULT_SUCCESS != result) {
+		return false;
+	}
+	curBuffer ^= 1;
+	g_mixer = m_mixer;
+	return true;
+}
+
+void OpenSLESStream::Stop()
+{
+	if (bqPlayerObject != NULL) {
+		(*bqPlayerObject)->Destroy(bqPlayerObject);
+		bqPlayerObject = NULL;
+		bqPlayerPlay = NULL;
+		bqPlayerBufferQueue = NULL;
+		bqPlayerMuteSolo = NULL;
+		bqPlayerVolume = NULL;
+	}
+	if (outputMixObject != NULL) {
+		(*outputMixObject)->Destroy(outputMixObject);
+		outputMixObject = NULL;
+	}
+	if (engineObject != NULL) {
+		(*engineObject)->Destroy(engineObject);
+		engineObject = NULL;
+		engineEngine = NULL;
+	}
+}
+#endif
@@ -0,0 +1,48 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program 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 Foundation, version 2.0.
+
+// This program 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 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+
+#ifndef _OPENSLSTREAM_H_
+#define _OPENSLSTREAM_H_
+
+#include "Thread.h"
+#include "SoundStream.h"
+
+class OpenSLESStream : public SoundStream
+{
+#ifdef ANDROID
+public:
+	OpenSLESStream(CMixer *mixer, void *hWnd = NULL)
+		: SoundStream(mixer)
+	{};
+
+	virtual ~OpenSLESStream() {};
+
+	virtual bool Start();
+	virtual void Stop();
+	static bool isValid() { return true; }
+	virtual bool usesMixer() const { return true; }
+
+private:
+	std::thread thread;
+	Common::Event soundSyncEvent;
+#else
+public:
+	OpenSLESStream(CMixer *mixer, void *hWnd = NULL): SoundStream(mixer) {}
+#endif // HAVE_OPENSL
+};
+
+#endif
@@ -1,9 +1,7 @@
-set(SRCS	Src/ABI.cpp
-			Src/BreakPoints.cpp
+set(SRCS	Src/BreakPoints.cpp
 			Src/CDUtils.cpp
 			Src/ColorUtil.cpp
 			Src/ConsoleListener.cpp
-			Src/CPUDetect.cpp
 			Src/FileSearch.cpp
 			Src/FileUtil.cpp
 			Src/Hash.cpp
@@ -20,10 +18,10 @@ set(SRCS	Src/ABI.cpp
 			Src/SymbolDB.cpp
 			Src/SysConf.cpp
 			Src/Thread.cpp
-			Src/Thunk.cpp
 			Src/Timer.cpp
 			Src/Version.cpp
 			Src/VideoBackendBase.cpp
+			Src/x64ABI.cpp
 			Src/x64Analyzer.cpp
 			Src/x64Emitter.cpp
 			Src/Crypto/aes_cbc.cpp
@@ -33,6 +31,23 @@ set(SRCS	Src/ABI.cpp
 			Src/Crypto/md5.cpp
 			Src/Crypto/sha1.cpp)

+if(_M_ARM) #ARM
+	set(SRCS	${SRCS}
+				Src/ArmCPUDetect.cpp
+				Src/ArmEmitter.cpp)
+else()
+	if(NOT _M_GENERIC) #X86
+		set(SRCS	${SRCS}
+					Src/x64FPURoundMode.cpp
+					Src/x64Thunk.cpp
+					)
+	endif()
+	set(SRCS ${SRCS} Src/x64CPUDetect.cpp)
+endif()
+if(_M_GENERIC) #Generic
+	set(SRCS	${SRCS}
+				Src/GenericFPURoundMode.cpp)
+endif()
 if(WIN32)
 	set(SRCS ${SRCS} Src/ExtendedTrace.cpp)
 endif(WIN32)
@@ -44,7 +44,7 @@
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
    <UseDebugLibraries>false</UseDebugLibraries>
    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <CharacterSet>MultiByte</CharacterSet>
+    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugFast|Win32'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
@@ -54,7 +54,7 @@
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
    <UseDebugLibraries>false</UseDebugLibraries>
    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <CharacterSet>MultiByte</CharacterSet>
+    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='DebugFast|x64'" Label="Configuration">
    <ConfigurationType>StaticLibrary</ConfigurationType>
@@ -158,12 +158,10 @@
    <Lib />
  </ItemDefinitionGroup>
  <ItemGroup>
-    <ClCompile Include="Src\ABI.cpp" />
    <ClCompile Include="Src\BreakPoints.cpp" />
    <ClCompile Include="Src\CDUtils.cpp" />
    <ClCompile Include="Src\ColorUtil.cpp" />
    <ClCompile Include="Src\ConsoleListener.cpp" />
-    <ClCompile Include="Src\CPUDetect.cpp" />
    <ClCompile Include="Src\Crypto\aes_cbc.cpp" />
    <ClCompile Include="Src\Crypto\aes_core.cpp" />
    <ClCompile Include="Src\Crypto\bn.cpp" />
@@ -195,15 +193,17 @@
    <ClCompile Include="Src\SymbolDB.cpp" />
    <ClCompile Include="Src\SysConf.cpp" />
    <ClCompile Include="Src\Thread.cpp" />
-    <ClCompile Include="Src\Thunk.cpp" />
    <ClCompile Include="Src\Timer.cpp" />
    <ClCompile Include="Src\Version.cpp" />
    <ClCompile Include="Src\VideoBackendBase.cpp" />
+    <ClCompile Include="Src\x64ABI.cpp" />
    <ClCompile Include="Src\x64Analyzer.cpp" />
+    <ClCompile Include="Src\x64CPUDetect.cpp" />
    <ClCompile Include="Src\x64Emitter.cpp" />
+    <ClCompile Include="Src\x64FPURoundMode.cpp" />
+    <ClCompile Include="Src\x64Thunk.cpp" />
  </ItemGroup>
  <ItemGroup>
-    <ClInclude Include="Src\ABI.h" />
    <ClInclude Include="Src\Atomic.h" />
    <ClInclude Include="Src\Atomic_GCC.h" />
    <ClInclude Include="Src\Atomic_Win32.h" />
@@ -251,6 +251,7 @@
    <ClInclude Include="Src\Thunk.h" />
    <ClInclude Include="Src\Timer.h" />
    <ClInclude Include="Src\VideoBackendBase.h" />
+    <ClInclude Include="Src\x64ABI.h" />
    <ClInclude Include="Src\x64Analyzer.h" />
    <ClInclude Include="Src\x64Emitter.h" />
  </ItemGroup>
@@ -1,11 +1,9 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
-    <ClCompile Include="Src\ABI.cpp" />
    <ClCompile Include="Src\BreakPoints.cpp" />
    <ClCompile Include="Src\CDUtils.cpp" />
    <ClCompile Include="Src\ColorUtil.cpp" />
-    <ClCompile Include="Src\CPUDetect.cpp" />
    <ClCompile Include="Src\ExtendedTrace.cpp" />
    <ClCompile Include="Src\FileSearch.cpp" />
    <ClCompile Include="Src\FileUtil.cpp" />
@@ -23,7 +21,6 @@
    <ClCompile Include="Src\SymbolDB.cpp" />
    <ClCompile Include="Src\SysConf.cpp" />
    <ClCompile Include="Src\Thread.cpp" />
-    <ClCompile Include="Src\Thunk.cpp" />
    <ClCompile Include="Src\Timer.cpp" />
    <ClCompile Include="Src\Version.cpp" />
    <ClCompile Include="Src\VideoBackendBase.cpp" />
@@ -53,9 +50,12 @@
    <ClCompile Include="Src\Crypto\sha1.cpp">
      <Filter>Crypto</Filter>
    </ClCompile>
+    <ClCompile Include="Src\x64ABI.cpp" />
+    <ClCompile Include="Src\x64CPUDetect.cpp" />
+    <ClCompile Include="Src\x64FPURoundMode.cpp" />
+    <ClCompile Include="Src\x64Thunk.cpp" />
  </ItemGroup>
  <ItemGroup>
-    <ClInclude Include="Src\ABI.h" />
    <ClInclude Include="Src\Atomic.h" />
    <ClInclude Include="Src\Atomic_GCC.h" />
    <ClInclude Include="Src\Atomic_Win32.h" />
@@ -121,6 +121,7 @@
    </ClInclude>
    <ClInclude Include="Src\StdMutex.h" />
    <ClInclude Include="Src\StdConditionVariable.h" />
+    <ClInclude Include="Src\x64ABI.h" />
  </ItemGroup>
  <ItemGroup>
    <None Include="CMakeLists.txt" />
@@ -0,0 +1,161 @@
+// Copyright (C) 2003 Dolphin Project.
+
+// This program 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 Foundation, version 2.0.
+
+// This program 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 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official SVN repository and contact information can be found at
+// http://code.google.com/p/dolphin-emu/
+
+#include "Common.h"
+#include "CPUDetect.h"
+#include "StringUtil.h"
+#include "FileUtil.h"
+
+const char procfile[] = "/proc/cpuinfo";
+
+char *GetCPUString()
+{
+	const char marker[] = "Hardware\t: ";
+	char *cpu_string = 0;
+	// Count the number of processor lines in /proc/cpuinfo
+	char buf[1024];
+
+	File::IOFile file(procfile, "r");
+	auto const fp = file.GetHandle();
+	if (!fp)
+		return 0;
+	
+	while (fgets(buf, sizeof(buf), fp))
+	{
+		if (strncmp(buf, marker, sizeof(marker) - 1))
+			continue;
+		cpu_string = buf + sizeof(marker) - 1;
+		cpu_string = strndup(cpu_string, strlen(cpu_string) - 1); // Strip the newline
+		break;
+	}
+	return cpu_string;
+}
+bool CheckCPUFeature(const char *feature)
+{
+	const char marker[] = "Features\t: ";
+	char buf[1024];
+	
+	File::IOFile file(procfile, "r");
+	auto const fp = file.GetHandle();
+	if (!fp)
+		return 0;
+	
+	while (fgets(buf, sizeof(buf), fp))
+	{
+		if (strncmp(buf, marker, sizeof(marker) - 1))
+			continue;
+		char *featurestring = buf + sizeof(marker) - 1;
+		char *token = strtok(featurestring, " ");
+		while (token != NULL)
+		{
+			if (strstr(token, feature))
+				return true; 
+			token = strtok(NULL, " ");
+		}
+	}
+	return false;
+}
+int GetCoreCount()
+{
+	const char marker[] = "processor\t: ";
+	int cores = 0;
+	char buf[1024];
+	
+	File::IOFile file(procfile, "r");
+	auto const fp = file.GetHandle();
+	if (!fp)
+		return 0;
+	
+	while (fgets(buf, sizeof(buf), fp))
+	{
+		if (strncmp(buf, marker, sizeof(marker) - 1))
+			continue;
+		++cores;
+	}
+	return cores;
+}
+
+CPUInfo cpu_info;
+
+CPUInfo::CPUInfo() {
+	Detect();
+}
+
+// Detects the various cpu features
+void CPUInfo::Detect()
+{
+	// Set some defaults here
+	// When ARMv8 cpus come out, these need to be updated.
+	HTT = false;
+	OS64bit = false;
+	CPU64bit = false;
+	Mode64bit = false;				 
+	vendor = VENDOR_ARM;
+	
+	// Get the information about the CPU 
+	strncpy(cpu_string, GetCPUString(), sizeof(cpu_string));
+	num_cores = GetCoreCount();	
+	bSwp = CheckCPUFeature("swp");
+	bHalf = CheckCPUFeature("half");
+	bThumb = CheckCPUFeature("thumb");
+	bFastMult = CheckCPUFeature("fastmult");
+	bVFP = CheckCPUFeature("vfp");
+	bEDSP = CheckCPUFeature("edsp");
+	bThumbEE = CheckCPUFeature("thumbee");
+	bNEON = CheckCPUFeature("neon");
+	bVFPv3 = CheckCPUFeature("vfpv3");
+	bTLS = CheckCPUFeature("tls");
+	bVFPv4 = CheckCPUFeature("vfpv4");
+	bIDIVa = CheckCPUFeature("idiva");
+	bIDIVt = CheckCPUFeature("idivt");
+	// These two are ARMv8 specific.
+	bFP = CheckCPUFeature("fp");
+	bASIMD = CheckCPUFeature("asimd");
+
+
+#if defined(__ARM_ARCH_7A__)
+	bArmV7 = true;
+#else
+	bArmV7 = false;
+#endif
+}
+
+// Turn the cpu info into a string we can show
+std::string CPUInfo::Summarize()
+{
+	std::string sum;
+	if (num_cores == 1)
+		sum = StringFromFormat("%s, %i core", cpu_string, num_cores);
+	else
+		sum = StringFromFormat("%s, %i cores", cpu_string, num_cores);
+
+	if (bSwp) sum += ", SWP";
+	if (bHalf) sum += ", Half";
+	if (bThumb) sum += ", Thumb";
+	if (bFastMult) sum += ", FastMult";
+	if (bVFP) sum += ", VFP";
+	if (bEDSP) sum += ", EDSP";
+	if (bThumbEE) sum += ", ThumbEE";
+	if (bNEON) sum += ", NEON";
+	if (bVFPv3) sum += ", VFPv3";
+	if (bTLS) sum += ", TLS";
+	if (bVFPv4) sum += ", VFPv4";
+	if (bIDIVa) sum += ", IDIVa";
+	if (bIDIVt) sum += ", IDIVt";
+
+	return sum;
+}
@@ -6,6 +6,7 @@
 #include <memory> // for std::unique_ptr
 #ifdef _WIN32
 #include <windows.h>
+#include "StringUtil.h"
 #elif __APPLE__
 #include <CoreFoundation/CoreFoundation.h>
 #include <IOKit/IOBSD.h>
@@ -25,7 +26,7 @@

 #ifdef _WIN32
 // takes a root drive path, returns true if it is a cdrom drive
-bool is_cdrom(const char drive[])
+bool is_cdrom(const TCHAR* drive)
 {
 	return (DRIVE_CDROM == GetDriveType(drive));
 }
@@ -36,15 +37,15 @@ std::vector<std::string> cdio_get_devices()
 	std::vector<std::string> drives;

 	const DWORD buffsize = GetLogicalDriveStrings(0, NULL);
-	std::unique_ptr<char[]> buff(new char[buffsize]);
-	if (GetLogicalDriveStrings(buffsize, buff.get()) == buffsize - 1)
+	std::vector<TCHAR> buff(buffsize);
+	if (GetLogicalDriveStrings(buffsize, buff.data()) == buffsize - 1)
 	{
-		const char* drive = buff.get();
+		auto drive = buff.data();
 		while (*drive)
 		{
 			if (is_cdrom(drive))
 			{
-				std::string str(drive);
+				std::string str(TStrToUTF8(drive));
 				str.pop_back();	// we don't want the final backslash
 				drives.push_back(std::move(str));
 			}
@@ -25,7 +25,8 @@ enum CPUVendor
 {
 	VENDOR_INTEL = 0,
 	VENDOR_AMD = 1,
-	VENDOR_OTHER = 2,
+	VENDOR_ARM = 2,
+	VENDOR_OTHER = 3,
 };

 struct CPUInfo
@@ -55,6 +56,26 @@ struct CPUInfo
 	bool bAES;
 	bool bLAHFSAHF64;
 	bool bLongMode;
+	
+	// ARM specific CPUInfo
+	bool bSwp;
+	bool bHalf;
+	bool bThumb;
+	bool bFastMult;
+	bool bVFP;
+	bool bEDSP;
+	bool bThumbEE;
+	bool bNEON;
+	bool bVFPv3;
+	bool bTLS;
+	bool bVFPv4;
+	bool bIDIVa;
+	bool bIDIVt;
+	bool bArmV7;  // enable MOVT, MOVW etc
+	
+	// ARMv8 specific
+	bool bFP;
+	bool bASIMD;

 	// Call Detect()
 	explicit CPUInfo();
@@ -29,6 +29,7 @@

 #include <map>
 #include <vector>
+#include <list>
 #include <deque>
 #include <string>

@@ -45,7 +46,8 @@ struct LinkedListItem : public T
 class PointerWrap
 {
 public:
-	enum Mode {
+	enum Mode
+	{
 		MODE_READ = 1, // load
 		MODE_WRITE, // save
 		MODE_MEASURE, // calculate size
@@ -57,124 +59,95 @@ public:

 public:
 	PointerWrap(u8 **ptr_, Mode mode_) : ptr(ptr_), mode(mode_) {}
-	PointerWrap(unsigned char **ptr_, int mode_) : ptr((u8**)ptr_), mode((Mode)mode_) {}

-	void SetMode(Mode mode_) {mode = mode_;}
-	Mode GetMode() const {return mode;}
-	u8 **GetPPtr() {return ptr;}
+	void SetMode(Mode mode_) { mode = mode_; }
+	Mode GetMode() const { return mode; }
+	u8** GetPPtr() { return ptr; }

-	void DoVoid(void *data, int size)
+	template <typename K, class V>
+	void Do(std::map<K, V>& x)
 	{
-		switch (mode) {
-		case MODE_READ:	memcpy(data, *ptr, size); break;
-		case MODE_WRITE: memcpy(*ptr, data, size); break;
-		case MODE_MEASURE: break;  // MODE_MEASURE - don't need to do anything
-		case MODE_VERIFY: for(int i = 0; i < size; i++) _dbg_assert_msg_(COMMON, ((u8*)data)[i] == (*ptr)[i], "Savestate verification failure: %d (0x%X) (at %p) != %d (0x%X) (at %p).\n", ((u8*)data)[i], ((u8*)data)[i], &((u8*)data)[i], (*ptr)[i], (*ptr)[i], &(*ptr)[i]); break;
-		default: break;  // throw an error?
-		}
-		(*ptr) += size;
-	}
-
-	template<class T>
-	void Do(std::map<unsigned int, T> &x)
-	{
-		unsigned int number = (unsigned int)x.size();
-		Do(number);
-		switch (mode) {
+		u32 count = (u32)x.size();
+		Do(count);
+		
+		switch (mode)
+		{
 		case MODE_READ:
+			for (x.clear(); count != 0; --count)
 			{
-				x.clear();
-				while (number > 0)
-				{
-					unsigned int first = 0;
-					Do(first);
-					T second;
-					Do(second);
-					x[first] = second;
-					--number;
-				}
+				std::pair<K, V> pair;
+				Do(pair.first);
+				Do(pair.second);
+				x.insert(pair);
 			}
 			break;
+		
 		case MODE_WRITE:
 		case MODE_MEASURE:
 		case MODE_VERIFY:
+			for (auto itr = x.begin(); itr != x.end(); ++itr)
 			{
-				typename std::map<unsigned int, T>::iterator itr = x.begin();
-				while (number > 0)
-				{
-					Do(itr->first);
-					Do(itr->second);
-					--number;
-					++itr;
-				}
+				Do(itr->first);
+				Do(itr->second);
 			}
 			break;
 		}
 	}
-
-	// Store vectors.
-	template<class T>
-	void Do(std::vector<T> &x)
-	{
-		u32 vec_size = (u32)x.size();
-		Do(vec_size);
-		x.resize(vec_size);
-		DoArray(&x[0], vec_size);
-	}
 	
-	// Store deques.
-	template<class T>
-	void Do(std::deque<T> &x)
+	template <typename T>
+	void DoContainer(T& x)
 	{
-		u32 deq_size = (u32)x.size();
-		Do(deq_size);
-		x.resize(deq_size);
-		u32 i;
-		for(i = 0; i < deq_size; i++)
-			DoVoid(&x[i],sizeof(T));
-	}
-	
-	// Store strings.
-	void Do(std::string &x) 
-	{
-		int stringLen = (int)x.length() + 1;
-		Do(stringLen);
+		u32 size = (u32)x.size();
+		Do(size);
+		x.resize(size);
 		
-		switch (mode) {
-		case MODE_READ:		x = (char*)*ptr; break;
-		case MODE_WRITE:	memcpy(*ptr, x.c_str(), stringLen); break;
-		case MODE_MEASURE: break;
-		case MODE_VERIFY: _dbg_assert_msg_(COMMON, !strcmp(x.c_str(), (char*)*ptr), "Savestate verification failure: \"%s\" != \"%s\" (at %p).\n", x.c_str(), (char*)*ptr, ptr); break;
-		}
-		(*ptr) += stringLen;
+		for (auto itr = x.begin(); itr != x.end(); ++itr)
+			Do(*itr);
 	}

-	void Do(std::wstring &x) 
+	template <typename T>
+	void Do(std::vector<T>& x)
 	{
-		int stringLen = sizeof(wchar_t)*((int)x.length() + 1);
-		Do(stringLen);
-
-		switch (mode) {
-		case MODE_READ:		x.assign((wchar_t*)*ptr, (stringLen / sizeof(wchar_t)) - 1); break;
-		case MODE_WRITE:	memcpy(*ptr, x.c_str(), stringLen); break;
-		case MODE_MEASURE: break;
-		case MODE_VERIFY: _dbg_assert_msg_(COMMON, x == (wchar_t*)*ptr, "Savestate verification failure: \"%ls\" != \"%ls\" (at %p).\n", x.c_str(), (wchar_t*)*ptr, ptr); break;
-		}
-		(*ptr) += stringLen;
+		DoContainer(x);
+	}
+	
+	template <typename T>
+	void Do(std::list<T>& x)
+	{
+		DoContainer(x);
+	}
+	
+	template <typename T>
+	void Do(std::deque<T>& x)
+	{
+		DoContainer(x);
+	}
+	
+	template <typename T>
+	void Do(std::basic_string<T>& x)
+	{
+		DoContainer(x);
 	}

-    template<class T>
-	void DoArray(T *x, int count) {
-        DoVoid((void *)x, sizeof(T) * count);
+    template <typename T>
+	void DoArray(T* x, u32 count)
+	{
+		for (u32 i = 0; i != count; ++i)
+			Do(x[i]);
    }
 	
-	template<class T>
-	void Do(T &x) {
-		DoVoid((void *)&x, sizeof(x));
+	template <typename T>
+	void Do(T& x)
+	{
+		// TODO: Bad, Do(some_non_POD) will compile and fail at runtime
+		// type_traits are not fully supported everywhere yet
+		
+		DoVoid((void*)&x, sizeof(x));
 	}

-	template<class T>
-	void DoPointer(T* &x, T*const base) {
+	template <typename T>
+	void DoPointer(T*& x, T* const base)
+	{
 		// pointers can be more than 2^31 apart, but you're using this function wrong if you need that much range
 		s32 offset = x - base;
 		Do(offset);
@@ -182,7 +155,8 @@ public:
 			x = base + offset;
 	}

-	template<class T, LinkedListItem<T>* (*TNew)(), void (*TFree)(LinkedListItem<T>*), void (*TDo)(PointerWrap&, T*)>
+	// Let's pretend std::list doesn't exist!
+	template <class T, LinkedListItem<T>* (*TNew)(), void (*TFree)(LinkedListItem<T>*), void (*TDo)(PointerWrap&, T*)>
 	void DoLinkedList(LinkedListItem<T>*& list_start, LinkedListItem<T>** list_end=0)
 	{
 		LinkedListItem<T>* list_cur = list_start;
@@ -242,25 +216,61 @@ public:
 		}
 	}

-	void DoMarker(const char* prevName, u32 arbitraryNumber=0x42)
+	void DoMarker(const char* prevName, u32 arbitraryNumber = 0x42)
 	{
 		u32 cookie = arbitraryNumber;
 		Do(cookie);
-		if(mode == PointerWrap::MODE_READ && cookie != arbitraryNumber)
+		
+		if (mode == PointerWrap::MODE_READ && cookie != arbitraryNumber)
 		{
-			PanicAlertT("Error: After \"%s\", found %d (0x%X) instead of save marker %d (0x%X). Aborting savestate load...", prevName, cookie, cookie, arbitraryNumber, arbitraryNumber);
+			PanicAlertT("Error: After \"%s\", found %d (0x%X) instead of save marker %d (0x%X). Aborting savestate load...",
+				prevName, cookie, cookie, arbitraryNumber, arbitraryNumber);
 			mode = PointerWrap::MODE_MEASURE;
 		}
 	}
+	
+private:
+	__forceinline void DoByte(u8& x)
+	{
+		switch (mode)
+		{
+		case MODE_READ:
+			x = **ptr;
+			break;
+			
+		case MODE_WRITE:
+			**ptr = x;
+			break;
+			
+		case MODE_MEASURE:
+			break;
+			
+		case MODE_VERIFY:
+			_dbg_assert_msg_(COMMON, (x == *ptr),
+				"Savestate verification failure: %d (0x%X) (at %p) != %d (0x%X) (at %p).\n",
+					x, x, &x, *ptr, *ptr, &*ptr);
+			break;
+			
+		default:
+			break;
+		}
+			
+		++(*ptr);
+	}
+	
+	void DoVoid(void *data, u32 size)
+	{
+		for(u32 i = 0; i != size; ++i)
+			DoByte(reinterpret_cast<u8*>(data)[i]);
+	}
 };

-
 class CChunkFileReader
 {
 public:
 	// Load file template
 	template<class T>
-	static bool Load(const std::string& _rFilename, int _Revision, T& _class) 
+	static bool Load(const std::string& _rFilename, u32 _Revision, T& _class)
 	{
 		INFO_LOG(COMMON, "ChunkReader: Loading %s" , _rFilename.c_str());

@@ -300,7 +310,7 @@ public:
 		}
 		
 		// get size
-		const int sz = (int)(fileSize - headerSize);
+		const u32 sz = (u32)(fileSize - headerSize);
 		if (header.ExpectedSize != sz)
 		{
 			ERROR_LOG(COMMON,"ChunkReader: Bad file size, got %d expected %d",
@@ -309,17 +319,16 @@ public:
 		}
 		
 		// read the state
-		u8* buffer = new u8[sz];
-		if (!pFile.ReadBytes(buffer, sz))
+		std::vector<u8> buffer(sz);
+		if (!pFile.ReadArray(&buffer[0], sz))
 		{
 			ERROR_LOG(COMMON,"ChunkReader: Error reading file");
 			return false;
 		}

-		u8 *ptr = buffer;
+		u8* ptr = &buffer[0];
 		PointerWrap p(&ptr, PointerWrap::MODE_READ);
 		_class.DoState(p);
-		delete[] buffer;
 		
 		INFO_LOG(COMMON, "ChunkReader: Done loading %s" , _rFilename.c_str());
 		return true;
@@ -327,7 +336,7 @@ public:
 	
 	// Save file template
 	template<class T>
-	static bool Save(const std::string& _rFilename, int _Revision, T& _class)
+	static bool Save(const std::string& _rFilename, u32 _Revision, T& _class)
 	{
 		INFO_LOG(COMMON, "ChunkReader: Writing %s" , _rFilename.c_str());
 		File::IOFile pFile(_rFilename, "wb");
@@ -349,9 +358,8 @@ public:
 		
 		// Create header
 		SChunkHeader header;
-		header.Compress = 0;
 		header.Revision = _Revision;
-		header.ExpectedSize = (int)sz;
+		header.ExpectedSize = (u32)sz;
 		
 		// Write to file
 		if (!pFile.WriteArray(&header, 1))
@@ -360,23 +368,21 @@ public:
 			return false;
 		}

-		if (!pFile.WriteBytes(&buffer[0], sz))
+		if (!pFile.WriteArray(&buffer[0], sz))
 		{
 			ERROR_LOG(COMMON,"ChunkReader: Failed writing data");
 			return false;
 		}
 		
-		INFO_LOG(COMMON,"ChunkReader: Done writing %s", 
-				 _rFilename.c_str());
+		INFO_LOG(COMMON,"ChunkReader: Done writing %s", _rFilename.c_str());
 		return true;
 	}
 	
 private:
 	struct SChunkHeader
 	{
-		int Revision;
-		int Compress;
-		int ExpectedSize;
+		u32 Revision;
+		u32 ExpectedSize;
 	};
 };

@@ -133,7 +133,9 @@ private:
 // wxWidgets does not have a true dummy macro for this.
 #define _trans(a) a

-#if defined __GNUC__
+#if defined _M_GENERIC
+#  define _M_SSE 0x0
+#elif defined __GNUC__
 # if defined __SSE4_2__
 #  define _M_SSE 0x402
 # elif defined __SSE4_1__
@@ -144,7 +146,7 @@ private:
 #  define _M_SSE 0x300
 # endif
 #elif (_MSC_VER >= 1500) || __INTEL_COMPILER // Visual Studio 2008
-# define _M_SSE 0x402
+#  define _M_SSE 0x402
 #endif

 // Host communication.
@@ -35,7 +35,7 @@ template<> struct CompileTimeAssert<true> {};
 #define b32(x)  (b16(x) | (b16(x) >>16) )
 #define ROUND_UP_POW2(x)	(b32(x - 1) + 1)

-#if defined __GNUC__ && !defined __SSSE3__
+#if defined __GNUC__ && !defined __SSSE3__ && !defined _M_GENERIC
 #include <emmintrin.h>
 static __inline __m128i __attribute__((__always_inline__))
 _mm_shuffle_epi8(__m128i a, __m128i mask)
@@ -60,6 +60,8 @@ _mm_shuffle_epi8(__m128i a, __m128i mask)
 // go to debugger mode
 	#ifdef GEKKO
 		#define Crash()
+	#elif defined _M_GENERIC
+		#define Crash() { exit(1); }
 	#else
 		#define Crash() {asm ("int $3");}
 	#endif
@@ -136,6 +138,15 @@ inline u8 swap8(u8 _data) {return _data;}
 inline u16 swap16(u16 _data) {return _byteswap_ushort(_data);}
 inline u32 swap32(u32 _data) {return _byteswap_ulong (_data);}
 inline u64 swap64(u64 _data) {return _byteswap_uint64(_data);}
+#elif _M_ARM
+#ifdef ANDROID
+#undef swap16
+#undef swap32
+#undef swap64
+#endif
+inline u16 swap16 (u16 _data) { u32 data = _data; __asm__ ("rev16 %0, %1\n" : "=l" (data) : "l" (data)); return (u16)data;} 
+inline u32 swap32 (u32 _data) {__asm__ ("rev %0, %1\n" : "=l" (_data) : "l" (_data)); return _data;} 
+inline u64 swap64(u64 _data) {return ((u64)swap32(_data) << 32) | swap32(_data >> 32);}
 #elif __linux__
 inline u16 swap16(u16 _data) {return bswap_16(_data);}
 inline u32 swap32(u32 _data) {return bswap_32(_data);}
@@ -36,6 +36,9 @@
 	// You can use the File::GetUserPath() util for this
 	#define USERDATA_DIR "Contents/Resources/User"
 	#define DOLPHIN_DATA_DIR "Library/Application Support/Dolphin"
+#elif defined ANDROID
+	#define USERDATA_DIR "user"
+	#define DOLPHIN_DATA_DIR "/sdcard/dolphin-emu"
 #else
 	#define USERDATA_DIR "user"
 	#ifdef USER_DIR
@@ -52,6 +55,8 @@
 	#define SYSDATA_DIR "Contents/Resources/Sys"
 	#define SHARED_USER_DIR	File::GetBundleDirectory() + \
 				DIR_SEP USERDATA_DIR DIR_SEP
+#elif defined ANDROID
+	#define SYSDATA_DIR "/sdcard/dolphin-emu"	
 #else
 	#ifdef DATA_DIR
 		#define SYSDATA_DIR DATA_DIR "sys"
@@ -61,7 +61,7 @@ void ConsoleListener::Open(bool Hidden, int Width, int Height, const char *Title
 		// Save the window handle that AllocConsole() created
 		hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
 		// Set the console window title
-		SetConsoleTitle(Title);
+		SetConsoleTitle(UTF8ToTStr(Title).c_str());
 		// Set letter space
 		LetterSpace(80, 4000);
 		//MoveWindow(GetConsoleWindow(), 200,200, 800,800, true);
@@ -195,7 +195,7 @@ void ConsoleListener::PixelSpace(int Left, int Top, int Width, int Height, bool

 	static const int MAX_BYTES = 1024 * 16;

-	std::vector<std::array<CHAR, MAX_BYTES>> Str;
+	std::vector<std::array<TCHAR, MAX_BYTES>> Str;
 	std::vector<std::array<WORD, MAX_BYTES>> Attr;

 	// ReadConsoleOutputAttribute seems to have a limit at this level
@@ -37,6 +37,8 @@
 #include <string.h>
 #include <stdio.h>

+#include "../FileUtil.h"
+
 /*
 * 32-bit integer manipulation macros (little endian)
 */
@@ -301,7 +303,10 @@ int md5_file( char *path, unsigned char output[16] )
    md5_context ctx;
    unsigned char buf[1024];

-    if( ( f = fopen( path, "rb" ) ) == NULL )
+	File::IOFile file(path, "rb");
+	f = file.GetHandle();
+
+    if (f == NULL)
        return( 1 );

    md5_starts( &ctx );
@@ -315,11 +320,9 @@ int md5_file( char *path, unsigned char output[16] )

    if( ferror( f ) != 0 )
    {
-        fclose( f );
        return( 2 );
    }

-    fclose( f );
    return( 0 );
 }

@@ -36,6 +36,8 @@
 #include <string.h>
 #include <stdio.h>

+#include "../FileUtil.h"
+
 /*
 * 32-bit integer manipulation macros (big endian)
 */
@@ -335,7 +337,10 @@ int sha1_file( char *path, unsigned char output[20] )
    sha1_context ctx;
    unsigned char buf[1024];

-    if( ( f = fopen( path, "rb" ) ) == NULL )
+	File::IOFile file(path, "rb");
+	f = file.GetHandle();
+
+    if (f == NULL)
        return( 1 );

    sha1_starts( &ctx );
@@ -349,11 +354,9 @@ int sha1_file( char *path, unsigned char output[20] )

    if( ferror( f ) != 0 )
    {
-        fclose( f );
        return( 2 );
    }

-    fclose( f );
    return( 0 );
 }

--- a/Show More
+++ b/Show More