Merge branch 'master' into wii-network

Conflicts:
	Source/Core/Core/Src/Boot/Boot_BS2Emu.cpp
	Source/Core/Core/Src/ConfigManager.cpp
	Source/Core/Core/Src/HLE/HLE_OS.h
	Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_es.cpp
	Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_es.h
	Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_net.cpp
	Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_net.h

CMakeLists.txt

@@ -5,6 +5,8 @@ cmake_minimum_required(VERSION 2.6)
 
 option(ANDROID "Enables a build for Android" OFF)
 option(USE_EGL "Enables EGL OpenGL Interface" OFF)
+option(USE_X11 "Enables X11 Support" ON)
+option(USE_WAYLAND "Enables Wayland Support" OFF)
 option(USE_GLES "Enables GLES And EGL, disables OGL" OFF)
 option(DISABLE_WX "Disable wxWidgets (use CLI interface)" OFF)
 
@@ -278,16 +280,28 @@ if(USE_GLES)
 	add_definitions(-DUSE_EGL=1)
 	set(USE_EGL True)
 endif()
+# For now Wayland and EGL are tied to each other.
+# The alternative would be an shm path
+if(USE_WAYLAND)
+	add_definitions(-DUSE_EGL)
+	set(USE_EGL 1)
+endif()
 
 if(USE_EGL)
 	message("EGL OpenGL interface enabled")
 	add_definitions(-DUSE_EGL=1)
+else()
+# Using GLX
+	set(USE_X11 1)
+	set(USE_WAYLAND 0)
 endif()
 add_definitions(-D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE)
 
 if(ANDROID)
 	message("Building for Android")
 	add_definitions(-DANDROID)
+	set(USE_X11 0)
+	set(USE_WAYLAND 0)
 endif()
 ########################################
 # Dependency checking
@@ -363,29 +377,53 @@ if(NOT ANDROID)
 		message("OpenAL NOT found, disabling OpenAL sound backend")
 	endif(OPENAL_FOUND)
 
+	if(UNIX AND NOT APPLE)
+# Note: The convention is to check USE_X11 or USE_WAYLAND where needed.
+# This is where we detect platforms and set the variables accordingly.
+		pkg_check_modules(WAYLAND wayland-egl wayland-client wayland-cursor)
+		if(USE_WAYLAND AND WAYLAND_FOUND)
+			pkg_check_modules(XKBCOMMON xkbcommon)
+			if(XKBCOMMON_FOUND)
+				set(USE_WAYLAND 1)
+				add_definitions(-DHAVE_WAYLAND)
+				include_directories(${WAYLAND_INCLUDE_DIR})
+				message("Wayland support enabled")
+			endif(XKBCOMMON_FOUND)
+		else()
+			set(USE_WAYLAND 0)
+			message("Wayland support disabled")
+			add_definitions(-DHAVE_WAYLAND=0)
+		endif(USE_WAYLAND AND WAYLAND_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(USE_X11 AND X11_FOUND)
-		if(X11_FOUND)
+			set(USE_X11 1)
 			add_definitions(-DHAVE_X11=1)
 			include_directories(${X11_INCLUDE_DIR})
-			message("X11 found")
+			message("X11 support enabled")
 		else()
-			message(FATAL_ERROR "X11 is required but not found")
+			set(USE_X11 0)
-		endif(X11_FOUND)
+			SET(X11_FOUND "")
-	else()
+			message("X11 support disabled")
-		add_definitions(-DHAVE_X11=0)
+			add_definitions(-DHAVE_X11=0)
+		endif(USE_X11 AND X11_FOUND)
+	
+		if (NOT USE_WAYLAND AND NOT USE_X11)
+			message(FATAL_ERROR "\n"
+			"No suitable display platform found\n"
+			"Requires wayland or x11 to run")
+		endif()
 	endif()
 
-	if(X11_FOUND)
+	if(USE_X11)
 		check_lib(XRANDR Xrandr)
+		if(XRANDR_FOUND)
+			add_definitions(-DHAVE_XRANDR=1)
+		else()
+			add_definitions(-DHAVE_XRANDR=0)
+		endif(XRANDR_FOUND)
 	endif()
-	if(XRANDR_FOUND)
-		add_definitions(-DHAVE_XRANDR=1)
-	else()
-		add_definitions(-DHAVE_XRANDR=0)
-	endif(XRANDR_FOUND)
-
 	if(ENCODE_FRAMEDUMPS)
 		check_libav()
 	endif()
@@ -458,6 +496,13 @@ else()
 	set(LZO lzo2)
 endif()
 
+if(ANDROID)
+	message("Using static libpng from Externals")
+	add_subdirectory(Externals/libpng)
+	include_directories(Externals/libpng)
+	set(PNG libpng)
+endif()
+
 if(OPENAL_FOUND)
 	if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 		check_lib(SOUNDTOUCH SoundTouch soundtouch/soundtouch.h QUIET)

Externals/libpng/CMakeLists.txt

@@ -1,19 +1,21 @@
-set(SRCS
+# OUR SOURCES
-	"png.c"
+set(SRCS
-	"pngerror.c"
+  png.h
-	"pngget.c"
+  pngconf.h
-	"pngmem.c"
+  png.c
-	"pngpread.c"
+  pngerror.c
-	"pngread.c"
+  pngget.c
-	"pngrio.c"
+  pngmem.c
-	"pngrtran.c"
+  pngpread.c
-	"pngrutil.c"
+  pngread.c
-	"pngset.c"
+  pngrio.c
-	"pngtrans.c"
+  pngrtran.c
-	"pngwio.c"
+  pngrutil.c
-	"pngwrite.c"
+  pngset.c
-	"pngwtran.c"
+  pngtrans.c
-	"pngwutil.c"
+  pngwio.c
-	)
+  pngwrite.c
-
+  pngwtran.c
-add_library(png STATIC ${SRCS})
+  pngwutil.c
+)
+add_library(png STATIC ${SRCS})

Externals/libpng/pngerror.c

@@ -1,447 +1,396 @@
-
+
-/* pngerror.c - stub functions for i/o and memory allocation
+/* pngerror.c - stub functions for i/o and memory allocation
- *
+ *
- * Last changed in libpng 1.5.1 [February 3, 2011]
+ * Last changed in libpng 1.2.45 [July 7, 2011]
- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2011 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
- *
+ *
- * This code is released under the libpng license.
+ * This code is released under the libpng license.
- * For conditions of distribution and use, see the disclaimer
+ * For conditions of distribution and use, see the disclaimer
- * and license in png.h
+ * and license in png.h
- *
+ *
- * This file provides a location for all error handling.  Users who
+ * This file provides a location for all error handling.  Users who
- * need special error handling are expected to write replacement functions
+ * need special error handling are expected to write replacement functions
- * and use png_set_error_fn() to use those functions.  See the instructions
+ * and use png_set_error_fn() to use those functions.  See the instructions
- * at each function.
+ * at each function.
- */
+ */
-
+
-#include "pngpriv.h"
+#define PNG_INTERNAL
-
+#define PNG_NO_PEDANTIC_WARNINGS
-#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
+#include "png.h"
-
+#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
-static PNG_FUNCTION(void, png_default_error,PNGARG((png_structp png_ptr,
+
-    png_const_charp error_message)),PNG_NORETURN);
+static void /* PRIVATE */
-
+png_default_error PNGARG((png_structp png_ptr,
-#ifdef PNG_WARNINGS_SUPPORTED
+  png_const_charp error_message)) PNG_NORETURN;
-static void /* PRIVATE */
+#ifdef PNG_WARNINGS_SUPPORTED
-png_default_warning PNGARG((png_structp png_ptr,
+static void /* PRIVATE */
-   png_const_charp warning_message));
+png_default_warning PNGARG((png_structp png_ptr,
-#endif /* PNG_WARNINGS_SUPPORTED */
+  png_const_charp warning_message));
-
+#endif /* PNG_WARNINGS_SUPPORTED */
-/* This function is called whenever there is a fatal error.  This function
+
- * should not be changed.  If there is a need to handle errors differently,
+/* This function is called whenever there is a fatal error.  This function
- * you should supply a replacement error function and use png_set_error_fn()
+ * should not be changed.  If there is a need to handle errors differently,
- * to replace the error function at run-time.
+ * you should supply a replacement error function and use png_set_error_fn()
- */
+ * to replace the error function at run-time.
-#ifdef PNG_ERROR_TEXT_SUPPORTED
+ */
-PNG_FUNCTION(void,PNGAPI
+#ifdef PNG_ERROR_TEXT_SUPPORTED
-png_error,(png_structp png_ptr, png_const_charp error_message),PNG_NORETURN)
+void PNGAPI
-{
+png_error(png_structp png_ptr, png_const_charp error_message)
-#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+{
-   char msg[16];
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
-   if (png_ptr != NULL)
+   char msg[16];
-   {
+   if (png_ptr != NULL)
-      if (png_ptr->flags&
+   {
-         (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
+     if (png_ptr->flags&
-      {
+       (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
-         if (*error_message == PNG_LITERAL_SHARP)
+     {
-         {
+       if (*error_message == PNG_LITERAL_SHARP)
-            /* Strip "#nnnn " from beginning of error message. */
+       {
-            int offset;
+           /* Strip "#nnnn " from beginning of error message. */
-            for (offset = 1; offset<15; offset++)
+           int offset;
-               if (error_message[offset] == ' ')
+           for (offset = 1; offset<15; offset++)
-                  break;
+              if (error_message[offset] == ' ')
-
+                  break;
-            if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
+           if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
-            {
+           {
-               int i;
+              int i;
-               for (i = 0; i < offset - 1; i++)
+              for (i = 0; i < offset - 1; i++)
-                  msg[i] = error_message[i + 1];
+                 msg[i] = error_message[i + 1];
-               msg[i - 1] = '\0';
+              msg[i - 1] = '\0';
-               error_message = msg;
+              error_message = msg;
-            }
+           }
-
+           else
-            else
+              error_message += offset;
-               error_message += offset;
+       }
-      }
+       else
-
+       {
-      else
+           if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
-      {
+           {
-         if (png_ptr->flags&PNG_FLAG_STRIP_ERROR_TEXT)
+              msg[0] = '0';
-         {
+              msg[1] = '\0';
-            msg[0] = '0';
+              error_message = msg;
-            msg[1] = '\0';
+           }
-            error_message = msg;
+       }
-         }
+     }
-       }
+   }
-     }
+#endif
-   }
+   if (png_ptr != NULL && png_ptr->error_fn != NULL)
-#endif
+      (*(png_ptr->error_fn))(png_ptr, error_message);
-   if (png_ptr != NULL && png_ptr->error_fn != NULL)
+
-      (*(png_ptr->error_fn))(png_ptr, error_message);
+   /* If the custom handler doesn't exist, or if it returns,
-
+      use the default handler, which will not return. */
-   /* If the custom handler doesn't exist, or if it returns,
+   png_default_error(png_ptr, error_message);
-      use the default handler, which will not return. */
+}
-   png_default_error(png_ptr, error_message);
+#else
-}
+void PNGAPI
-#else
+png_err(png_structp png_ptr)
-PNG_FUNCTION(void,PNGAPI
+{
-png_err,(png_structp png_ptr),PNG_NORETURN)
+   /* Prior to 1.2.45 the error_fn received a NULL pointer, expressed
-{
+    * erroneously as '\0', instead of the empty string "".  This was
-   if (png_ptr != NULL && png_ptr->error_fn != NULL)
+    * apparently an error, introduced in libpng-1.2.20, and png_default_error
-      (*(png_ptr->error_fn))(png_ptr, '\0');
+    * will crash in this case.
-
+    */
-   /* If the custom handler doesn't exist, or if it returns,
+   if (png_ptr != NULL && png_ptr->error_fn != NULL)
-      use the default handler, which will not return. */
+      (*(png_ptr->error_fn))(png_ptr, "");
-   png_default_error(png_ptr, '\0');
+
-}
+   /* If the custom handler doesn't exist, or if it returns,
-#endif /* PNG_ERROR_TEXT_SUPPORTED */
+      use the default handler, which will not return. */
-
+   png_default_error(png_ptr, "");
-#ifdef PNG_WARNINGS_SUPPORTED
+}
-/* This function is called whenever there is a non-fatal error.  This function
+#endif /* PNG_ERROR_TEXT_SUPPORTED */
- * should not be changed.  If there is a need to handle warnings differently,
+
- * you should supply a replacement warning function and use
+#ifdef PNG_WARNINGS_SUPPORTED
- * png_set_error_fn() to replace the warning function at run-time.
+/* This function is called whenever there is a non-fatal error.  This function
- */
+ * should not be changed.  If there is a need to handle warnings differently,
-void PNGAPI
+ * you should supply a replacement warning function and use
-png_warning(png_structp png_ptr, png_const_charp warning_message)
+ * png_set_error_fn() to replace the warning function at run-time.
-{
+ */
-   int offset = 0;
+void PNGAPI
-   if (png_ptr != NULL)
+png_warning(png_structp png_ptr, png_const_charp warning_message)
-   {
+{
-#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+   int offset = 0;
-   if (png_ptr->flags&
+   if (png_ptr != NULL)
-       (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
+   {
-#endif
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
-      {
+   if (png_ptr->flags&
-         if (*warning_message == PNG_LITERAL_SHARP)
+     (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))
-         {
+#endif
-            for (offset = 1; offset < 15; offset++)
+     {
-               if (warning_message[offset] == ' ')
+       if (*warning_message == PNG_LITERAL_SHARP)
-                  break;
+       {
-         }
+           for (offset = 1; offset < 15; offset++)
-      }
+              if (warning_message[offset] == ' ')
-   }
+                  break;
-   if (png_ptr != NULL && png_ptr->warning_fn != NULL)
+       }
-      (*(png_ptr->warning_fn))(png_ptr, warning_message + offset);
+     }
-   else
+   }
-      png_default_warning(png_ptr, warning_message + offset);
+   if (png_ptr != NULL && png_ptr->warning_fn != NULL)
-}
+      (*(png_ptr->warning_fn))(png_ptr, warning_message + offset);
-#endif /* PNG_WARNINGS_SUPPORTED */
+   else
-
+      png_default_warning(png_ptr, warning_message + offset);
-#ifdef PNG_BENIGN_ERRORS_SUPPORTED
+}
-void PNGAPI
+#endif /* PNG_WARNINGS_SUPPORTED */
-png_benign_error(png_structp png_ptr, png_const_charp error_message)
+
-{
+#ifdef PNG_BENIGN_ERRORS_SUPPORTED
-  if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
+void PNGAPI
-     png_warning(png_ptr, error_message);
+png_benign_error(png_structp png_ptr, png_const_charp error_message)
-  else
+{
-     png_error(png_ptr, error_message);
+  if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
-}
+    png_warning(png_ptr, error_message);
-#endif
+  else
-
+    png_error(png_ptr, error_message);
-/* These utilities are used internally to build an error message that relates
+}
- * to the current chunk.  The chunk name comes from png_ptr->chunk_name,
+#endif
- * this is used to prefix the message.  The message is limited in length
+
- * to 63 bytes, the name characters are output as hex digits wrapped in []
+/* These utilities are used internally to build an error message that relates
- * if the character is invalid.
+ * to the current chunk.  The chunk name comes from png_ptr->chunk_name,
- */
+ * this is used to prefix the message.  The message is limited in length
-#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
+ * to 63 bytes, the name characters are output as hex digits wrapped in []
-static PNG_CONST char png_digit[16] = {
+ * if the character is invalid.
-   '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+ */
-   'A', 'B', 'C', 'D', 'E', 'F'
+#define isnonalpha(c) ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
-};
+static PNG_CONST char png_digit[16] = {
-
+   '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
-#define PNG_MAX_ERROR_TEXT 64
+   'A', 'B', 'C', 'D', 'E', 'F'
-#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)
+};
-static void /* PRIVATE */
+
-png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp
+#define PNG_MAX_ERROR_TEXT 64
-    error_message)
+#if defined(PNG_WARNINGS_SUPPORTED) || defined(PNG_ERROR_TEXT_SUPPORTED)
-{
+static void /* PRIVATE */
-   int iout = 0, iin = 0;
+png_format_buffer(png_structp png_ptr, png_charp buffer, png_const_charp
-
+   error_message)
-   while (iin < 4)
+{
-   {
+   int iout = 0, iin = 0;
-      int c = png_ptr->chunk_name[iin++];
+
-      if (isnonalpha(c))
+   while (iin < 4)
-      {
+   {
-         buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET;
+      int c = png_ptr->chunk_name[iin++];
-         buffer[iout++] = png_digit[(c & 0xf0) >> 4];
+      if (isnonalpha(c))
-         buffer[iout++] = png_digit[c & 0x0f];
+      {
-         buffer[iout++] = PNG_LITERAL_RIGHT_SQUARE_BRACKET;
+         buffer[iout++] = PNG_LITERAL_LEFT_SQUARE_BRACKET;
-      }
+         buffer[iout++] = png_digit[(c & 0xf0) >> 4];
-
+         buffer[iout++] = png_digit[c & 0x0f];
-      else
+         buffer[iout++] = PNG_LITERAL_RIGHT_SQUARE_BRACKET;
-      {
+      }
-         buffer[iout++] = (png_byte)c;
+      else
-      }
+      {
-   }
+         buffer[iout++] = (png_byte)c;
-
+      }
-   if (error_message == NULL)
+   }
-      buffer[iout] = '\0';
+
-
+   if (error_message == NULL)
-   else
+      buffer[iout] = '\0';
-   {
+   else
-      buffer[iout++] = ':';
+   {
-      buffer[iout++] = ' ';
+      buffer[iout++] = ':';
-      png_memcpy(buffer + iout, error_message, PNG_MAX_ERROR_TEXT);
+      buffer[iout++] = ' ';
-      buffer[iout + PNG_MAX_ERROR_TEXT - 1] = '\0';
+
-   }
+      iin = 0;
-}
+      while (iin < PNG_MAX_ERROR_TEXT-1 && error_message[iin] != '\0')
-#endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */
+         buffer[iout++] = error_message[iin++];
-
+
-#if defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED)
+      /* iin < PNG_MAX_ERROR_TEXT, so the following is safe: */
-PNG_FUNCTION(void,PNGAPI
+      buffer[iout] = '\0';
-png_chunk_error,(png_structp png_ptr, png_const_charp error_message),
+   }
-   PNG_NORETURN)
+}
-{
+
-   char msg[18+PNG_MAX_ERROR_TEXT];
+#ifdef PNG_READ_SUPPORTED
-   if (png_ptr == NULL)
+void PNGAPI
-      png_error(png_ptr, error_message);
+png_chunk_error(png_structp png_ptr, png_const_charp error_message)
-
+{
-   else
+   char msg[18+PNG_MAX_ERROR_TEXT];
-   {
+   if (png_ptr == NULL)
-      png_format_buffer(png_ptr, msg, error_message);
+     png_error(png_ptr, error_message);
-      png_error(png_ptr, msg);
+   else
-   }
+   {
-}
+     png_format_buffer(png_ptr, msg, error_message);
-#endif /* PNG_READ_SUPPORTED && PNG_ERROR_TEXT_SUPPORTED */
+     png_error(png_ptr, msg);
-
+   }
-#ifdef PNG_WARNINGS_SUPPORTED
+}
-void PNGAPI
+#endif /* PNG_READ_SUPPORTED */
-png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)
+#endif /* PNG_WARNINGS_SUPPORTED || PNG_ERROR_TEXT_SUPPORTED */
-{
+
-   char msg[18+PNG_MAX_ERROR_TEXT];
+#ifdef PNG_WARNINGS_SUPPORTED
-   if (png_ptr == NULL)
+void PNGAPI
-      png_warning(png_ptr, warning_message);
+png_chunk_warning(png_structp png_ptr, png_const_charp warning_message)
-
+{
-   else
+   char msg[18+PNG_MAX_ERROR_TEXT];
-   {
+   if (png_ptr == NULL)
-      png_format_buffer(png_ptr, msg, warning_message);
+     png_warning(png_ptr, warning_message);
-      png_warning(png_ptr, msg);
+   else
-   }
+   {
-}
+     png_format_buffer(png_ptr, msg, warning_message);
-#endif /* PNG_WARNINGS_SUPPORTED */
+     png_warning(png_ptr, msg);
-
+   }
-#ifdef PNG_READ_SUPPORTED
+}
-#ifdef PNG_BENIGN_ERRORS_SUPPORTED
+#endif /* PNG_WARNINGS_SUPPORTED */
-void PNGAPI
+
-png_chunk_benign_error(png_structp png_ptr, png_const_charp error_message)
+#ifdef PNG_READ_SUPPORTED
-{
+#ifdef PNG_BENIGN_ERRORS_SUPPORTED
-   if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
+void PNGAPI
-      png_chunk_warning(png_ptr, error_message);
+png_chunk_benign_error(png_structp png_ptr, png_const_charp error_message)
-
+{
-   else
+  if (png_ptr->flags & PNG_FLAG_BENIGN_ERRORS_WARN)
-      png_chunk_error(png_ptr, error_message);
+    png_chunk_warning(png_ptr, error_message);
-}
+  else
-#endif
+    png_chunk_error(png_ptr, error_message);
-#endif /* PNG_READ_SUPPORTED */
+}
-
+#endif
-#ifdef PNG_ERROR_TEXT_SUPPORTED
+#endif /* PNG_READ_SUPPORTED */
-#ifdef PNG_FLOATING_POINT_SUPPORTED
+
-PNG_FUNCTION(void,
+/* This is the default error handling function.  Note that replacements for
-png_fixed_error,(png_structp png_ptr, png_const_charp name),PNG_NORETURN)
+ * this function MUST NOT RETURN, or the program will likely crash.  This
-{
+ * function is used by default, or if the program supplies NULL for the
-#  define fixed_message "fixed point overflow in "
+ * error function pointer in png_set_error_fn().
-#  define fixed_message_ln ((sizeof fixed_message)-1)
+ */
-   int  iin;
+static void /* PRIVATE */
-   char msg[fixed_message_ln+PNG_MAX_ERROR_TEXT];
+png_default_error(png_structp png_ptr, png_const_charp error_message)
-   png_memcpy(msg, fixed_message, fixed_message_ln);
+{
-   iin = 0;
+#ifdef PNG_CONSOLE_IO_SUPPORTED
-   if (name != NULL) while (iin < (PNG_MAX_ERROR_TEXT-1) && name[iin] != 0)
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
-   {
+   if (*error_message == PNG_LITERAL_SHARP)
-      msg[fixed_message_ln + iin] = name[iin];
+   {
-      ++iin;
+     /* Strip "#nnnn " from beginning of error message. */
-   }
+     int offset;
-   msg[fixed_message_ln + iin] = 0;
+     char error_number[16];
-   png_error(png_ptr, msg);
+     for (offset = 0; offset<15; offset++)
-}
+     {
-#endif
+         error_number[offset] = error_message[offset + 1];
-#endif
+         if (error_message[offset] == ' ')
-
+             break;
-#ifdef PNG_SETJMP_SUPPORTED
+     }
-/* This API only exists if ANSI-C style error handling is used,
+     if ((offset > 1) && (offset < 15))
- * otherwise it is necessary for png_default_error to be overridden.
+     {
- */
+       error_number[offset - 1] = '\0';
-jmp_buf* PNGAPI
+       fprintf(stderr, "libpng error no. %s: %s",
-png_set_longjmp_fn(png_structp png_ptr, png_longjmp_ptr longjmp_fn,
+          error_number, error_message + offset + 1);
-    size_t jmp_buf_size)
+       fprintf(stderr, PNG_STRING_NEWLINE);
-{
+     }
-   if (png_ptr == NULL || jmp_buf_size != png_sizeof(jmp_buf))
+     else
-      return NULL;
+     {
-
+       fprintf(stderr, "libpng error: %s, offset=%d",
-   png_ptr->longjmp_fn = longjmp_fn;
+          error_message, offset);
-   return &png_ptr->png_jmpbuf;
+       fprintf(stderr, PNG_STRING_NEWLINE);
-}
+     }
-#endif
+   }
-
+   else
-/* This is the default error handling function.  Note that replacements for
+#endif
- * this function MUST NOT RETURN, or the program will likely crash.  This
+   {
- * function is used by default, or if the program supplies NULL for the
+      fprintf(stderr, "libpng error: %s", error_message);
- * error function pointer in png_set_error_fn().
+      fprintf(stderr, PNG_STRING_NEWLINE);
- */
+   }
-static PNG_FUNCTION(void /* PRIVATE */,
+#endif
-png_default_error,(png_structp png_ptr, png_const_charp error_message),
+
-   PNG_NORETURN)
+#ifdef PNG_SETJMP_SUPPORTED
-{
+   if (png_ptr)
-#ifdef PNG_CONSOLE_IO_SUPPORTED
+   {
-#ifdef PNG_ERROR_NUMBERS_SUPPORTED
+#  ifdef USE_FAR_KEYWORD
-   if (*error_message == PNG_LITERAL_SHARP)
+   {
-   {
+      jmp_buf jmpbuf;
-      /* Strip "#nnnn " from beginning of error message. */
+      png_memcpy(jmpbuf, png_ptr->jmpbuf, png_sizeof(jmp_buf));
-      int offset;
+     longjmp(jmpbuf,1);
-      char error_number[16];
+   }
-      for (offset = 0; offset<15; offset++)
+#  else
-      {
+   longjmp(png_ptr->jmpbuf, 1);
-         error_number[offset] = error_message[offset + 1];
+#  endif
-         if (error_message[offset] == ' ')
+   }
-            break;
+#endif
-      }
+   /* Here if not setjmp support or if png_ptr is null. */
-
+   PNG_ABORT();
-      if ((offset > 1) && (offset < 15))
+#ifndef PNG_CONSOLE_IO_SUPPORTED
-      {
+   error_message = error_message; /* Make compiler happy */
-         error_number[offset - 1] = '\0';
+#endif
-         fprintf(stderr, "libpng error no. %s: %s",
+}
-             error_number, error_message + offset + 1);
+
-         fprintf(stderr, PNG_STRING_NEWLINE);
+#ifdef PNG_WARNINGS_SUPPORTED
-      }
+/* This function is called when there is a warning, but the library thinks
-
+ * it can continue anyway.  Replacement functions don't have to do anything
-      else
+ * here if you don't want them to.  In the default configuration, png_ptr is
-      {
+ * not used, but it is passed in case it may be useful.
-         fprintf(stderr, "libpng error: %s, offset=%d",
+ */
-             error_message, offset);
+static void /* PRIVATE */
-         fprintf(stderr, PNG_STRING_NEWLINE);
+png_default_warning(png_structp png_ptr, png_const_charp warning_message)
-      }
+{
-   }
+#ifdef PNG_CONSOLE_IO_SUPPORTED
-   else
+#  ifdef PNG_ERROR_NUMBERS_SUPPORTED
-#endif
+   if (*warning_message == PNG_LITERAL_SHARP)
-   {
+   {
-      fprintf(stderr, "libpng error: %s", error_message);
+     int offset;
-      fprintf(stderr, PNG_STRING_NEWLINE);
+     char warning_number[16];
-   }
+     for (offset = 0; offset < 15; offset++)
-#endif
+     {
-#ifndef PNG_CONSOLE_IO_SUPPORTED
+        warning_number[offset] = warning_message[offset + 1];
-   PNG_UNUSED(error_message) /* Make compiler happy */
+        if (warning_message[offset] == ' ')
-#endif
+            break;
-   png_longjmp(png_ptr, 1);
+     }
-}
+     if ((offset > 1) && (offset < 15))
-
+     {
-PNG_FUNCTION(void,PNGAPI
+       warning_number[offset + 1] = '\0';
-png_longjmp,(png_structp png_ptr, int val),PNG_NORETURN)
+       fprintf(stderr, "libpng warning no. %s: %s",
-{
+          warning_number, warning_message + offset);
-#ifdef PNG_SETJMP_SUPPORTED
+       fprintf(stderr, PNG_STRING_NEWLINE);
-   if (png_ptr && png_ptr->longjmp_fn)
+     }
-   {
+     else
-#  ifdef USE_FAR_KEYWORD
+     {
-      {
+       fprintf(stderr, "libpng warning: %s",
-         jmp_buf png_jmpbuf;
+          warning_message);
-         png_memcpy(png_jmpbuf, png_ptr->png_jmpbuf, png_sizeof(jmp_buf));
+       fprintf(stderr, PNG_STRING_NEWLINE);
-         png_ptr->longjmp_fn(png_jmpbuf, val);
+     }
-      }
+   }
-
+   else
-#  else
+#  endif
-   png_ptr->longjmp_fn(png_ptr->png_jmpbuf, val);
+   {
-#  endif
+     fprintf(stderr, "libpng warning: %s", warning_message);
-   }
+     fprintf(stderr, PNG_STRING_NEWLINE);
-#endif
+   }
-   /* Here if not setjmp support or if png_ptr is null. */
+#else
-   PNG_ABORT();
+   warning_message = warning_message; /* Make compiler happy */
-}
+#endif
-
+   png_ptr = png_ptr; /* Make compiler happy */
-#ifdef PNG_WARNINGS_SUPPORTED
+}
-/* This function is called when there is a warning, but the library thinks
+#endif /* PNG_WARNINGS_SUPPORTED */
- * it can continue anyway.  Replacement functions don't have to do anything
+
- * here if you don't want them to.  In the default configuration, png_ptr is
+/* This function is called when the application wants to use another method
- * not used, but it is passed in case it may be useful.
+ * of handling errors and warnings.  Note that the error function MUST NOT
- */
+ * return to the calling routine or serious problems will occur.  The return
-static void /* PRIVATE */
+ * method used in the default routine calls longjmp(png_ptr->jmpbuf, 1)
-png_default_warning(png_structp png_ptr, png_const_charp warning_message)
+ */
-{
+void PNGAPI
-#ifdef PNG_CONSOLE_IO_SUPPORTED
+png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
-#  ifdef PNG_ERROR_NUMBERS_SUPPORTED
+   png_error_ptr error_fn, png_error_ptr warning_fn)
-   if (*warning_message == PNG_LITERAL_SHARP)
+{
-   {
+   if (png_ptr == NULL)
-      int offset;
+      return;
-      char warning_number[16];
+   png_ptr->error_ptr = error_ptr;
-      for (offset = 0; offset < 15; offset++)
+   png_ptr->error_fn = error_fn;
-      {
+   png_ptr->warning_fn = warning_fn;
-         warning_number[offset] = warning_message[offset + 1];
+}
-         if (warning_message[offset] == ' ')
+
-            break;
+
-      }
+/* This function returns a pointer to the error_ptr associated with the user
-
+ * functions.  The application should free any memory associated with this
-      if ((offset > 1) && (offset < 15))
+ * pointer before png_write_destroy and png_read_destroy are called.
-      {
+ */
-         warning_number[offset + 1] = '\0';
+png_voidp PNGAPI
-         fprintf(stderr, "libpng warning no. %s: %s",
+png_get_error_ptr(png_structp png_ptr)
-             warning_number, warning_message + offset);
+{
-         fprintf(stderr, PNG_STRING_NEWLINE);
+   if (png_ptr == NULL)
-      }
+      return NULL;
-
+   return ((png_voidp)png_ptr->error_ptr);
-      else
+}
-      {
+
-         fprintf(stderr, "libpng warning: %s",
+
-             warning_message);
+#ifdef PNG_ERROR_NUMBERS_SUPPORTED
-         fprintf(stderr, PNG_STRING_NEWLINE);
+void PNGAPI
-      }
+png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)
-   }
+{
-   else
+   if (png_ptr != NULL)
-#  endif
+   {
-
+     png_ptr->flags &=
-   {
+       ((~(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);
-      fprintf(stderr, "libpng warning: %s", warning_message);
+   }
-      fprintf(stderr, PNG_STRING_NEWLINE);
+}
-   }
+#endif
-#else
+#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */
-   PNG_UNUSED(warning_message) /* Make compiler happy */
-#endif
-   PNG_UNUSED(png_ptr) /* Make compiler happy */
-}
-#endif /* PNG_WARNINGS_SUPPORTED */
-
-/* This function is called when the application wants to use another method
- * of handling errors and warnings.  Note that the error function MUST NOT
- * return to the calling routine or serious problems will occur.  The return
- * method used in the default routine calls longjmp(png_ptr->png_jmpbuf, 1)
- */
-void PNGAPI
-png_set_error_fn(png_structp png_ptr, png_voidp error_ptr,
-    png_error_ptr error_fn, png_error_ptr warning_fn)
-{
-   if (png_ptr == NULL)
-      return;
-
-   png_ptr->error_ptr = error_ptr;
-   png_ptr->error_fn = error_fn;
-   png_ptr->warning_fn = warning_fn;
-}
-
-
-/* This function returns a pointer to the error_ptr associated with the user
- * functions.  The application should free any memory associated with this
- * pointer before png_write_destroy and png_read_destroy are called.
- */
-png_voidp PNGAPI
-png_get_error_ptr(png_const_structp png_ptr)
-{
-   if (png_ptr == NULL)
-      return NULL;
-
-   return ((png_voidp)png_ptr->error_ptr);
-}
-
-
-#ifdef PNG_ERROR_NUMBERS_SUPPORTED
-void PNGAPI
-png_set_strip_error_numbers(png_structp png_ptr, png_uint_32 strip_mode)
-{
-   if (png_ptr != NULL)
-   {
-      png_ptr->flags &=
-         ((~(PNG_FLAG_STRIP_ERROR_NUMBERS |
-         PNG_FLAG_STRIP_ERROR_TEXT))&strip_mode);
-   }
-}
-#endif
-#endif /* PNG_READ_SUPPORTED || PNG_WRITE_SUPPORTED */

Externals/libpng/pnggccrd.c

@@ -0,0 +1,26 @@
+/* pnggccrd.c
+ *
+ * Last changed in libpng 1.2.48 [March 8, 2012]
+ * Copyright (c) 1998-2012 Glenn Randers-Pehrson
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * This code snippet is for use by configure's compilation test. Most of the
+ * remainder of the file was removed from libpng-1.2.20, and all of the
+ * assembler code was removed from libpng-1.2.48.
+ */
+
+#if (!defined _MSC_VER) && \
+    defined(PNG_ASSEMBLER_CODE_SUPPORTED) && \
+    defined(PNG_MMX_CODE_SUPPORTED)
+
+int PNGAPI png_dummy_mmx_support(void);
+
+int PNGAPI png_dummy_mmx_support(void)
+{
+     /* 0: no MMX; 1: MMX supported; 2: not tested */
+     return 2;
+}
+#endif

Externals/libpng/pngrio.c

@@ -1,176 +1,180 @@
-
+
-/* pngrio.c - functions for data input
+/* pngrio.c - functions for data input
- *
+ *
- * Last changed in libpng 1.5.0 [January 6, 2011]
+ * Last changed in libpng 1.2.43 [February 25, 2010]
- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2010 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
- *
+ *
- * This code is released under the libpng license.
+ * This code is released under the libpng license.
- * For conditions of distribution and use, see the disclaimer
+ * For conditions of distribution and use, see the disclaimer
- * and license in png.h
+ * and license in png.h
- *
+ *
- * This file provides a location for all input.  Users who need
+ * This file provides a location for all input.  Users who need
- * special handling are expected to write a function that has the same
+ * special handling are expected to write a function that has the same
- * arguments as this and performs a similar function, but that possibly
+ * arguments as this and performs a similar function, but that possibly
- * has a different input method.  Note that you shouldn't change this
+ * has a different input method.  Note that you shouldn't change this
- * function, but rather write a replacement function and then make
+ * function, but rather write a replacement function and then make
- * libpng use it at run time with png_set_read_fn(...).
+ * libpng use it at run time with png_set_read_fn(...).
- */
+ */
-
+
-#include "pngpriv.h"
+#define PNG_INTERNAL
-
+#define PNG_NO_PEDANTIC_WARNINGS
-#ifdef PNG_READ_SUPPORTED
+#include "png.h"
-
+#ifdef PNG_READ_SUPPORTED
-/* Read the data from whatever input you are using.  The default routine
+
- * reads from a file pointer.  Note that this routine sometimes gets called
+/* Read the data from whatever input you are using.  The default routine
- * with very small lengths, so you should implement some kind of simple
+ * reads from a file pointer.  Note that this routine sometimes gets called
- * buffering if you are using unbuffered reads.  This should never be asked
+ * with very small lengths, so you should implement some kind of simple
- * to read more then 64K on a 16 bit machine.
+ * buffering if you are using unbuffered reads.  This should never be asked
- */
+ * to read more then 64K on a 16 bit machine.
-void /* PRIVATE */
+ */
-png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+void /* PRIVATE */
-{
+png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
-   png_debug1(4, "reading %d bytes", (int)length);
+{
-
+   png_debug1(4, "reading %d bytes", (int)length);
-   if (png_ptr->read_data_fn != NULL)
+ 
-      (*(png_ptr->read_data_fn))(png_ptr, data, length);
+   if (png_ptr->read_data_fn != NULL)
-
+      (*(png_ptr->read_data_fn))(png_ptr, data, length);
-   else
+   else
-      png_error(png_ptr, "Call to NULL read function");
+      png_error(png_ptr, "Call to NULL read function");
-}
+}
-
+
-#ifdef PNG_STDIO_SUPPORTED
+#ifdef PNG_STDIO_SUPPORTED
-/* This is the function that does the actual reading of data.  If you are
+/* This is the function that does the actual reading of data.  If you are
- * not reading from a standard C stream, you should create a replacement
+ * not reading from a standard C stream, you should create a replacement
- * read_data function and use it at run time with png_set_read_fn(), rather
+ * read_data function and use it at run time with png_set_read_fn(), rather
- * than changing the library.
+ * than changing the library.
- */
+ */
-#  ifndef USE_FAR_KEYWORD
+#ifndef USE_FAR_KEYWORD
-void PNGCBAPI
+void PNGAPI
-png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
-{
+{
-   png_size_t check;
+   png_size_t check;
-
+
-   if (png_ptr == NULL)
+   if (png_ptr == NULL)
-      return;
+      return;
-
+   /* fread() returns 0 on error, so it is OK to store this in a png_size_t
-   /* fread() returns 0 on error, so it is OK to store this in a png_size_t
+    * instead of an int, which is what fread() actually returns.
-    * instead of an int, which is what fread() actually returns.
+    */
-    */
+#ifdef _WIN32_WCE
-   check = fread(data, 1, length, (png_FILE_p)png_ptr->io_ptr);
+   if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) )
-
+      check = 0;
-   if (check != length)
+#else
-      png_error(png_ptr, "Read Error");
+   check = (png_size_t)fread(data, (png_size_t)1, length,
-}
+      (png_FILE_p)png_ptr->io_ptr);
-#  else
+#endif
-/* This is the model-independent version. Since the standard I/O library
+
-   can't handle far buffers in the medium and small models, we have to copy
+   if (check != length)
-   the data.
+      png_error(png_ptr, "Read Error");
-*/
+}
-
+#else
-#define NEAR_BUF_SIZE 1024
+/* This is the model-independent version. Since the standard I/O library
-#define MIN(a,b) (a <= b ? a : b)
+   can't handle far buffers in the medium and small models, we have to copy
-
+   the data.
-static void PNGCBAPI
+*/
-png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
+
-{
+#define NEAR_BUF_SIZE 1024
-   png_size_t check;
+#define MIN(a,b) (a <= b ? a : b)
-   png_byte *n_data;
+
-   png_FILE_p io_ptr;
+static void PNGAPI
-
+png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
-   if (png_ptr == NULL)
+{
-      return;
+   int check;
-
+   png_byte *n_data;
-   /* Check if data really is near. If so, use usual code. */
+   png_FILE_p io_ptr;
-   n_data = (png_byte *)CVT_PTR_NOCHECK(data);
+
-   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
+   if (png_ptr == NULL)
-
+      return;
-   if ((png_bytep)n_data == data)
+   /* Check if data really is near. If so, use usual code. */
-   {
+   n_data = (png_byte *)CVT_PTR_NOCHECK(data);
-      check = fread(n_data, 1, length, io_ptr);
+   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
-   }
+   if ((png_bytep)n_data == data)
-
+   {
-   else
+#ifdef _WIN32_WCE
-   {
+      if ( !ReadFile((HANDLE)(png_ptr->io_ptr), data, length, &check,
-      png_byte buf[NEAR_BUF_SIZE];
+          NULL) )
-      png_size_t read, remaining, err;
+         check = 0;
-      check = 0;
+#else
-      remaining = length;
+      check = fread(n_data, 1, length, io_ptr);
-
+#endif
-      do
+   }
-      {
+   else
-         read = MIN(NEAR_BUF_SIZE, remaining);
+   {
-         err = fread(buf, 1, read, io_ptr);
+      png_byte buf[NEAR_BUF_SIZE];
-         png_memcpy(data, buf, read); /* copy far buffer to near buffer */
+      png_size_t read, remaining, err;
-
+      check = 0;
-         if (err != read)
+      remaining = length;
-            break;
+      do
-
+      {
-         else
+         read = MIN(NEAR_BUF_SIZE, remaining);
-            check += err;
+#ifdef _WIN32_WCE
-
+         if ( !ReadFile((HANDLE)(io_ptr), buf, read, &err, NULL) )
-         data += read;
+            err = 0;
-         remaining -= read;
+#else
-      }
+         err = fread(buf, (png_size_t)1, read, io_ptr);
-      while (remaining != 0);
+#endif
-   }
+         png_memcpy(data, buf, read); /* copy far buffer to near buffer */
-
+         if (err != read)
-   if ((png_uint_32)check != (png_uint_32)length)
+            break;
-      png_error(png_ptr, "read Error");
+         else
-}
+            check += err;
-#  endif
+         data += read;
-#endif
+         remaining -= read;
-
+      }
-/* This function allows the application to supply a new input function
+      while (remaining != 0);
- * for libpng if standard C streams aren't being used.
+   }
- *
+   if ((png_uint_32)check != (png_uint_32)length)
- * This function takes as its arguments:
+      png_error(png_ptr, "read Error");
- *
+}
- * png_ptr      - pointer to a png input data structure
+#endif
- *
+#endif
- * io_ptr       - pointer to user supplied structure containing info about
+
- *                the input functions.  May be NULL.
+/* This function allows the application to supply a new input function
- *
+ * for libpng if standard C streams aren't being used.
- * read_data_fn - pointer to a new input function that takes as its
+ *
- *                arguments a pointer to a png_struct, a pointer to
+ * This function takes as its arguments:
- *                a location where input data can be stored, and a 32-bit
+ * png_ptr      - pointer to a png input data structure
- *                unsigned int that is the number of bytes to be read.
+ * io_ptr       - pointer to user supplied structure containing info about
- *                To exit and output any fatal error messages the new write
+ *                the input functions.  May be NULL.
- *                function should call png_error(png_ptr, "Error msg").
+ * read_data_fn - pointer to a new input function that takes as its
- *                May be NULL, in which case libpng's default function will
+ *                arguments a pointer to a png_struct, a pointer to
- *                be used.
+ *                a location where input data can be stored, and a 32-bit
- */
+ *                unsigned int that is the number of bytes to be read.
-void PNGAPI
+ *                To exit and output any fatal error messages the new write
-png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,
+ *                function should call png_error(png_ptr, "Error msg").
-   png_rw_ptr read_data_fn)
+ *                May be NULL, in which case libpng's default function will
-{
+ *                be used.
-   if (png_ptr == NULL)
+ */
-      return;
+void PNGAPI
-
+png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,
-   png_ptr->io_ptr = io_ptr;
+   png_rw_ptr read_data_fn)
-
+{
-#ifdef PNG_STDIO_SUPPORTED
+   if (png_ptr == NULL)
-   if (read_data_fn != NULL)
+      return;
-      png_ptr->read_data_fn = read_data_fn;
+   png_ptr->io_ptr = io_ptr;
-
+
-   else
+#ifdef PNG_STDIO_SUPPORTED
-      png_ptr->read_data_fn = png_default_read_data;
+   if (read_data_fn != NULL)
-#else
+      png_ptr->read_data_fn = read_data_fn;
-   png_ptr->read_data_fn = read_data_fn;
+   else
-#endif
+      png_ptr->read_data_fn = png_default_read_data;
-
+#else
-   /* It is an error to write to a read device */
+   png_ptr->read_data_fn = read_data_fn;
-   if (png_ptr->write_data_fn != NULL)
+#endif
-   {
+
-      png_ptr->write_data_fn = NULL;
+   /* It is an error to write to a read device */
-      png_warning(png_ptr,
+   if (png_ptr->write_data_fn != NULL)
-          "Can't set both read_data_fn and write_data_fn in the"
+   {
-          " same structure");
+      png_ptr->write_data_fn = NULL;
-   }
+      png_warning(png_ptr,
-
+         "It's an error to set both read_data_fn and write_data_fn in the ");
-#ifdef PNG_WRITE_FLUSH_SUPPORTED
+      png_warning(png_ptr,
-   png_ptr->output_flush_fn = NULL;
+         "same structure.  Resetting write_data_fn to NULL.");
-#endif
+   }
-}
+
-#endif /* PNG_READ_SUPPORTED */
+#ifdef PNG_WRITE_FLUSH_SUPPORTED
+   png_ptr->output_flush_fn = NULL;
+#endif
+}
+#endif /* PNG_READ_SUPPORTED */

Externals/libpng/pngvcrd.c

@@ -0,0 +1,12 @@
+/* pngvcrd.c
+ *
+ * Last changed in libpng 1.2.48 [March 8, 2012]
+ * Copyright (c) 1998-2012 Glenn Randers-Pehrson
+ *
+ * This code is released under the libpng license.
+ * For conditions of distribution and use, see the disclaimer
+ * and license in png.h
+ *
+ * This nearly empty file is for use by configure's compilation test. The
+ * remainder of the file  was removed from libpng-1.2.20.
+ */

Externals/libpng/pngwio.c

@@ -1,254 +1,260 @@
-
+
-/* pngwio.c - functions for data output
+/* pngwio.c - functions for data output
- *
+ *
- * Last changed in libpng 1.5.0 [January 6, 2011]
+ * Last changed in libpng 1.2.41 [December 3, 2009]
- * Copyright (c) 1998-2011 Glenn Randers-Pehrson
+ * Copyright (c) 1998-2009 Glenn Randers-Pehrson
- * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
+ * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
- * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
+ * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
- *
+ *
- * This code is released under the libpng license.
+ * This code is released under the libpng license.
- * For conditions of distribution and use, see the disclaimer
+ * For conditions of distribution and use, see the disclaimer
- * and license in png.h
+ * and license in png.h
- *
+ *
- * This file provides a location for all output.  Users who need
+ * This file provides a location for all output.  Users who need
- * special handling are expected to write functions that have the same
+ * special handling are expected to write functions that have the same
- * arguments as these and perform similar functions, but that possibly
+ * arguments as these and perform similar functions, but that possibly
- * use different output methods.  Note that you shouldn't change these
+ * use different output methods.  Note that you shouldn't change these
- * functions, but rather write replacement functions and then change
+ * functions, but rather write replacement functions and then change
- * them at run time with png_set_write_fn(...).
+ * them at run time with png_set_write_fn(...).
- */
+ */
-
+
-#include "pngpriv.h"
+#define PNG_INTERNAL
-
+#define PNG_NO_PEDANTIC_WARNINGS
-#ifdef PNG_WRITE_SUPPORTED
+#include "png.h"
-
+#ifdef PNG_WRITE_SUPPORTED
-/* Write the data to whatever output you are using.  The default routine
+
- * writes to a file pointer.  Note that this routine sometimes gets called
+/* Write the data to whatever output you are using.  The default routine
- * with very small lengths, so you should implement some kind of simple
+ * writes to a file pointer.  Note that this routine sometimes gets called
- * buffering if you are using unbuffered writes.  This should never be asked
+ * with very small lengths, so you should implement some kind of simple
- * to write more than 64K on a 16 bit machine.
+ * buffering if you are using unbuffered writes.  This should never be asked
- */
+ * to write more than 64K on a 16 bit machine.
-
+ */
-void /* PRIVATE */
+
-png_write_data(png_structp png_ptr, png_const_bytep data, png_size_t length)
+void /* PRIVATE */
-{
+png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
-   /* NOTE: write_data_fn must not change the buffer! */
+{
-   if (png_ptr->write_data_fn != NULL )
+   if (png_ptr->write_data_fn != NULL )
-      (*(png_ptr->write_data_fn))(png_ptr, (png_bytep)data, length);
+      (*(png_ptr->write_data_fn))(png_ptr, data, length);
-
+   else
-   else
+      png_error(png_ptr, "Call to NULL write function");
-      png_error(png_ptr, "Call to NULL write function");
+}
-}
+
-
+#ifdef PNG_STDIO_SUPPORTED
-#ifdef PNG_STDIO_SUPPORTED
+/* This is the function that does the actual writing of data.  If you are
-/* This is the function that does the actual writing of data.  If you are
+ * not writing to a standard C stream, you should create a replacement
- * not writing to a standard C stream, you should create a replacement
+ * write_data function and use it at run time with png_set_write_fn(), rather
- * write_data function and use it at run time with png_set_write_fn(), rather
+ * than changing the library.
- * than changing the library.
+ */
- */
+#ifndef USE_FAR_KEYWORD
-#ifndef USE_FAR_KEYWORD
+void PNGAPI
-void PNGCBAPI
+png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
-png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+{
-{
+   png_uint_32 check;
-   png_size_t check;
+
-
+   if (png_ptr == NULL)
-   if (png_ptr == NULL)
+      return;
-      return;
+#ifdef _WIN32_WCE
-
+   if ( !WriteFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) )
-   check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr));
+      check = 0;
-
+#else
-   if (check != length)
+   check = fwrite(data, 1, length, (png_FILE_p)(png_ptr->io_ptr));
-      png_error(png_ptr, "Write Error");
+#endif
-}
+   if (check != length)
-#else
+      png_error(png_ptr, "Write Error");
-/* This is the model-independent version. Since the standard I/O library
+}
- * can't handle far buffers in the medium and small models, we have to copy
+#else
- * the data.
+/* This is the model-independent version. Since the standard I/O library
- */
+ * can't handle far buffers in the medium and small models, we have to copy
-
+ * the data.
-#define NEAR_BUF_SIZE 1024
+ */
-#define MIN(a,b) (a <= b ? a : b)
+
-
+#define NEAR_BUF_SIZE 1024
-void PNGCBAPI
+#define MIN(a,b) (a <= b ? a : b)
-png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
+
-{
+void PNGAPI
-   png_uint_32 check;
+png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
-   png_byte *near_data;  /* Needs to be "png_byte *" instead of "png_bytep" */
+{
-   png_FILE_p io_ptr;
+   png_uint_32 check;
-
+   png_byte *near_data;  /* Needs to be "png_byte *" instead of "png_bytep" */
-   if (png_ptr == NULL)
+   png_FILE_p io_ptr;
-      return;
+
-
+   if (png_ptr == NULL)
-   /* Check if data really is near. If so, use usual code. */
+      return;
-   near_data = (png_byte *)CVT_PTR_NOCHECK(data);
+   /* Check if data really is near. If so, use usual code. */
-   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
+   near_data = (png_byte *)CVT_PTR_NOCHECK(data);
-
+   io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
-   if ((png_bytep)near_data == data)
+   if ((png_bytep)near_data == data)
-   {
+   {
-      check = fwrite(near_data, 1, length, io_ptr);
+#ifdef _WIN32_WCE
-   }
+      if ( !WriteFile(io_ptr, near_data, length, &check, NULL) )
-
+         check = 0;
-   else
+#else
-   {
+      check = fwrite(near_data, 1, length, io_ptr);
-      png_byte buf[NEAR_BUF_SIZE];
+#endif
-      png_size_t written, remaining, err;
+   }
-      check = 0;
+   else
-      remaining = length;
+   {
-
+      png_byte buf[NEAR_BUF_SIZE];
-      do
+      png_size_t written, remaining, err;
-      {
+      check = 0;
-         written = MIN(NEAR_BUF_SIZE, remaining);
+      remaining = length;
-         png_memcpy(buf, data, written); /* Copy far buffer to near buffer */
+      do
-         err = fwrite(buf, 1, written, io_ptr);
+      {
-
+         written = MIN(NEAR_BUF_SIZE, remaining);
-         if (err != written)
+         png_memcpy(buf, data, written); /* Copy far buffer to near buffer */
-            break;
+#ifdef _WIN32_WCE
-
+         if ( !WriteFile(io_ptr, buf, written, &err, NULL) )
-         else
+            err = 0;
-            check += err;
+#else
-
+         err = fwrite(buf, 1, written, io_ptr);
-         data += written;
+#endif
-         remaining -= written;
+         if (err != written)
-      }
+            break;
-      while (remaining != 0);
+
-   }
+         else
-
+            check += err;
-   if (check != length)
+
-      png_error(png_ptr, "Write Error");
+         data += written;
-}
+         remaining -= written;
-
+      }
-#endif
+      while (remaining != 0);
-#endif
+   }
-
+   if (check != length)
-/* This function is called to output any data pending writing (normally
+      png_error(png_ptr, "Write Error");
- * to disk).  After png_flush is called, there should be no data pending
+}
- * writing in any buffers.
+
- */
+#endif
-#ifdef PNG_WRITE_FLUSH_SUPPORTED
+#endif
-void /* PRIVATE */
+
-png_flush(png_structp png_ptr)
+/* This function is called to output any data pending writing (normally
-{
+ * to disk).  After png_flush is called, there should be no data pending
-   if (png_ptr->output_flush_fn != NULL)
+ * writing in any buffers.
-      (*(png_ptr->output_flush_fn))(png_ptr);
+ */
-}
+#ifdef PNG_WRITE_FLUSH_SUPPORTED
-
+void /* PRIVATE */
-#  ifdef PNG_STDIO_SUPPORTED
+png_flush(png_structp png_ptr)
-void PNGCBAPI
+{
-png_default_flush(png_structp png_ptr)
+   if (png_ptr->output_flush_fn != NULL)
-{
+      (*(png_ptr->output_flush_fn))(png_ptr);
-   png_FILE_p io_ptr;
+}
-
+
-   if (png_ptr == NULL)
+#ifdef PNG_STDIO_SUPPORTED
-      return;
+void PNGAPI
-
+png_default_flush(png_structp png_ptr)
-   io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr));
+{
-   fflush(io_ptr);
+#ifndef _WIN32_WCE
-}
+   png_FILE_p io_ptr;
-#  endif
+#endif
-#endif
+   if (png_ptr == NULL)
-
+      return;
-/* This function allows the application to supply new output functions for
+#ifndef _WIN32_WCE
- * libpng if standard C streams aren't being used.
+   io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr));
- *
+   fflush(io_ptr);
- * This function takes as its arguments:
+#endif
- * png_ptr       - pointer to a png output data structure
+}
- * io_ptr        - pointer to user supplied structure containing info about
+#endif
- *                 the output functions.  May be NULL.
+#endif
- * write_data_fn - pointer to a new output function that takes as its
+
- *                 arguments a pointer to a png_struct, a pointer to
+/* This function allows the application to supply new output functions for
- *                 data to be written, and a 32-bit unsigned int that is
+ * libpng if standard C streams aren't being used.
- *                 the number of bytes to be written.  The new write
+ *
- *                 function should call png_error(png_ptr, "Error msg")
+ * This function takes as its arguments:
- *                 to exit and output any fatal error messages.  May be
+ * png_ptr       - pointer to a png output data structure
- *                 NULL, in which case libpng's default function will
+ * io_ptr        - pointer to user supplied structure containing info about
- *                 be used.
+ *                 the output functions.  May be NULL.
- * flush_data_fn - pointer to a new flush function that takes as its
+ * write_data_fn - pointer to a new output function that takes as its
- *                 arguments a pointer to a png_struct.  After a call to
+ *                 arguments a pointer to a png_struct, a pointer to
- *                 the flush function, there should be no data in any buffers
+ *                 data to be written, and a 32-bit unsigned int that is
- *                 or pending transmission.  If the output method doesn't do
+ *                 the number of bytes to be written.  The new write
- *                 any buffering of output, a function prototype must still be
+ *                 function should call png_error(png_ptr, "Error msg")
- *                 supplied although it doesn't have to do anything.  If
+ *                 to exit and output any fatal error messages.  May be
- *                 PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile
+ *                 NULL, in which case libpng's default function will
- *                 time, output_flush_fn will be ignored, although it must be
+ *                 be used.
- *                 supplied for compatibility.  May be NULL, in which case
+ * flush_data_fn - pointer to a new flush function that takes as its
- *                 libpng's default function will be used, if
+ *                 arguments a pointer to a png_struct.  After a call to
- *                 PNG_WRITE_FLUSH_SUPPORTED is defined.  This is not
+ *                 the flush function, there should be no data in any buffers
- *                 a good idea if io_ptr does not point to a standard
+ *                 or pending transmission.  If the output method doesn't do
- *                 *FILE structure.
+ *                 any buffering of output, a function prototype must still be
- */
+ *                 supplied although it doesn't have to do anything.  If
-void PNGAPI
+ *                 PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile
-png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,
+ *                 time, output_flush_fn will be ignored, although it must be
-    png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)
+ *                 supplied for compatibility.  May be NULL, in which case
-{
+ *                 libpng's default function will be used, if
-   if (png_ptr == NULL)
+ *                 PNG_WRITE_FLUSH_SUPPORTED is defined.  This is not
-      return;
+ *                 a good idea if io_ptr does not point to a standard
-
+ *                 *FILE structure.
-   png_ptr->io_ptr = io_ptr;
+ */
-
+void PNGAPI
-#ifdef PNG_STDIO_SUPPORTED
+png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,
-   if (write_data_fn != NULL)
+   png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)
-      png_ptr->write_data_fn = write_data_fn;
+{
-
+   if (png_ptr == NULL)
-   else
+      return;
-      png_ptr->write_data_fn = png_default_write_data;
+
-#else
+   png_ptr->io_ptr = io_ptr;
-   png_ptr->write_data_fn = write_data_fn;
+
-#endif
+#ifdef PNG_STDIO_SUPPORTED
-
+   if (write_data_fn != NULL)
-#ifdef PNG_WRITE_FLUSH_SUPPORTED
+      png_ptr->write_data_fn = write_data_fn;
-#  ifdef PNG_STDIO_SUPPORTED
+
-
+   else
-   if (output_flush_fn != NULL)
+      png_ptr->write_data_fn = png_default_write_data;
-      png_ptr->output_flush_fn = output_flush_fn;
+#else
-
+   png_ptr->write_data_fn = write_data_fn;
-   else
+#endif
-      png_ptr->output_flush_fn = png_default_flush;
+
-
+#ifdef PNG_WRITE_FLUSH_SUPPORTED
-#  else
+#ifdef PNG_STDIO_SUPPORTED
-   png_ptr->output_flush_fn = output_flush_fn;
+   if (output_flush_fn != NULL)
-#  endif
+      png_ptr->output_flush_fn = output_flush_fn;
-#endif /* PNG_WRITE_FLUSH_SUPPORTED */
+
-
+   else
-   /* It is an error to read while writing a png file */
+      png_ptr->output_flush_fn = png_default_flush;
-   if (png_ptr->read_data_fn != NULL)
+#else
-   {
+   png_ptr->output_flush_fn = output_flush_fn;
-      png_ptr->read_data_fn = NULL;
+#endif
-
+#endif /* PNG_WRITE_FLUSH_SUPPORTED */
-      png_warning(png_ptr,
+
-          "Can't set both read_data_fn and write_data_fn in the"
+   /* It is an error to read while writing a png file */
-          " same structure");
+   if (png_ptr->read_data_fn != NULL)
-   }
+   {
-}
+      png_ptr->read_data_fn = NULL;
-
+      png_warning(png_ptr,
-#ifdef USE_FAR_KEYWORD
+         "Attempted to set both read_data_fn and write_data_fn in");
-#  ifdef _MSC_VER
+      png_warning(png_ptr,
-void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)
+         "the same structure.  Resetting read_data_fn to NULL.");
-{
+   }
-   void *near_ptr;
+}
-   void FAR *far_ptr;
+
-   FP_OFF(near_ptr) = FP_OFF(ptr);
+#ifdef USE_FAR_KEYWORD
-   far_ptr = (void FAR *)near_ptr;
+#ifdef _MSC_VER
-
+void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)
-   if (check != 0)
+{
-      if (FP_SEG(ptr) != FP_SEG(far_ptr))
+   void *near_ptr;
-         png_error(png_ptr, "segment lost in conversion");
+   void FAR *far_ptr;
-
+   FP_OFF(near_ptr) = FP_OFF(ptr);
-   return(near_ptr);
+   far_ptr = (void FAR *)near_ptr;
-}
+
-#  else
+   if (check != 0)
-void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)
+      if (FP_SEG(ptr) != FP_SEG(far_ptr))
-{
+         png_error(png_ptr, "segment lost in conversion");
-   void *near_ptr;
+
-   void FAR *far_ptr;
+   return(near_ptr);
-   near_ptr = (void FAR *)ptr;
+}
-   far_ptr = (void FAR *)near_ptr;
+#  else
-
+void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)
-   if (check != 0)
+{
-      if (far_ptr != ptr)
+   void *near_ptr;
-         png_error(png_ptr, "segment lost in conversion");
+   void FAR *far_ptr;
-
+   near_ptr = (void FAR *)ptr;
-   return(near_ptr);
+   far_ptr = (void FAR *)near_ptr;
-}
+
-#  endif
+   if (check != 0)
-#endif
+      if (far_ptr != ptr)
-#endif /* PNG_WRITE_SUPPORTED */
+         png_error(png_ptr, "segment lost in conversion");
+
+   return(near_ptr);
+}
+#   endif
+#   endif
+#endif /* PNG_WRITE_SUPPORTED */

Source/Android/.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>

Source/Android/.gitignore

@@ -0,0 +1,7 @@
+gen
+obj
+#ui_atlas.zim
+ui_atlas.zim.png
+#assets/ui_atlas.zim
+#jni/ui_atlas.cpp
+#jni/ui_atlas.h

Source/Android/.project

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>ppsspp</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>

Source/Android/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,4 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.compliance=1.5
+org.eclipse.jdt.core.compiler.source=1.5

Source/Android/AndroidManifest.xml

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="org.dolphinemu.dolphinemu"
+    android:versionCode="2"
+    android:versionName="0.2" >
+
+    <uses-sdk android:minSdkVersion="14" android:targetSdkVersion="14"/>
+    
+    <uses-feature android:glEsVersion="0x00020000"></uses-feature>
+		<uses-feature android:name="android.hardware.screen.landscape" />
+		<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
+		<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
+		
+		<application
+        android:icon="@drawable/launcher"
+        android:label="@string/app_name">
+        <activity
+            android:name=".DolphinEmulator"
+            android:label="@string/app_name"
+            android:theme="@android:style/Theme.NoTitleBar.Fullscreen"
+            android:screenOrientation="landscape"
+            android:configChanges="locale|keyboard|keyboardHidden|navigation|fontScale|uiMode" >
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+        <activity 
+            android:name=".NativeListView"
+            android:label="@string/app_name"
+            android:theme="@android:style/Theme"
+            android:configChanges="orientation|locale|keyboard|keyboardHidden|navigation|fontScale|uiMode" >
+        </activity>
+    </application>
+
+</manifest>

Source/Android/assets/GCPadNew.ini

@@ -0,0 +1,29 @@
+[GCPad1]
+Device = Android/0/Touchscreen
+Buttons/A = Button 0
+Buttons/B = Button 1
+Buttons/X = C
+Buttons/Y = S
+Buttons/Z = D
+Buttons/Start = Button 2
+Main Stick/Up = Up
+Main Stick/Down = Down
+Main Stick/Left = Left
+Main Stick/Right = Right
+Main Stick/Modifier = Shift_L
+Main Stick/Modifier/Range = 50.000000
+C-Stick/Up = I
+C-Stick/Down = K
+C-Stick/Left = J
+C-Stick/Right = L
+C-Stick/Modifier = Control_L
+C-Stick/Modifier/Range = 50.000000
+Triggers/L = Q
+Triggers/R = W
+D-Pad/Up = T
+D-Pad/Down = G
+D-Pad/Left = F
+D-Pad/Right = H
+[GCPad2]
+[GCPad3]
+[GCPad4]

Source/Android/build.xml

@@ -0,0 +1,92 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project name="Dolphin Emulator" 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>

Source/Android/custom_rules.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project name="Dolphin" default="help">
+    <property name="ndkbuildopt" value=""/>
+    <target name="-pre-build">
+        <exec executable="${ndk.dir}/ndk-build" failonerror="true">
+            <arg line="-j4 ${ndkbuildopt}"/>
+        </exec>
+	<copy todir="${jar.libs.dir}/armeabi-v7a">
+		<fileset
+			dir="../../libs/armeabi-v7a"
+			includes="libdolphin-emu-nogui.so" />
+	</copy>
+    </target>
+    <target name="clean" depends="android_rules.clean">
+        <exec executable="${ndk.dir}/ndk-build" failonerror="true">
+            <arg value="clean"/>
+        </exec>
+    </target>
+</project>

Source/Android/jni/Application.mk

@@ -0,0 +1,4 @@
+APP_STL := stlport_static
+APP_ABI := armeabi-v7a 
+
+#APP_ABI := armeabi-v7a

Source/Android/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-17

Source/Android/res/layout/main.xml

@@ -0,0 +1,26 @@
+<?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" >
+
+    <TextView
+        android:id="@+id/TextView01"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginLeft="5dip"
+        android:layout_marginTop="5dip"
+        android:singleLine="true"
+        android:text="@+id/TextView01"
+        android:textStyle="bold" >
+    </TextView>
+
+    <TextView
+        android:id="@+id/TextView02"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginLeft="10dip"
+        android:text="@+id/TextView02" >
+    </TextView>
+
+</LinearLayout>

Source/Android/res/values/strings.xml

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

Source/Android/src/org/dolphinemu/dolphinemu/DolphinEmulator.java

@@ -0,0 +1,176 @@
+package org.dolphinemu.dolphinemu;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.Environment;
+import android.util.DisplayMetrics;
+import android.util.Log;
+import android.view.MotionEvent;
+import android.view.WindowManager;
+
+public class DolphinEmulator<MainActivity> extends Activity 
+{	
+	static private NativeGLSurfaceView GLview = null;
+	static private boolean Running = false;
+	
+	private float screenWidth;
+	private float screenHeight;
+	
+	public static native void onTouchEvent(int Action, float X, float Y);
+	
+	static
+	{
+		try
+		{
+			System.loadLibrary("dolphin-emu-nogui"); 
+		}
+		catch (Exception ex)
+		{
+			Log.w("me", ex.toString());
+		}
+	}
+	private void CopyAsset(String asset, String output) {
+        InputStream in = null;
+        OutputStream out = null;
+        try {
+          in = getAssets().open(asset);
+          out = new FileOutputStream(output);
+          copyFile(in, out);
+          in.close();
+          in = null;
+          out.flush();
+          out.close();
+          out = null;
+        } catch(IOException e) {
+            Log.e("tag", "Failed to copy asset file: " + asset, e);
+        }       
+	}
+	private void copyFile(InputStream in, OutputStream out) throws IOException {
+	    byte[] buffer = new byte[1024];
+	    int read;
+	    while((read = in.read(buffer)) != -1){
+	      out.write(buffer, 0, read);
+	    }
+	}
+	
+	@Override
+	public void onStop()
+	{
+		super.onStop();
+		if (Running)
+			NativeGLSurfaceView.StopEmulation();
+	}
+	@Override
+	public void onPause()
+	{
+		super.onPause();
+		if (Running)
+			NativeGLSurfaceView.PauseEmulation();
+	}
+	@Override
+	public void onResume()
+	{
+		super.onResume();
+		if (Running)
+			NativeGLSurfaceView.UnPauseEmulation();
+	}
+
+    /** Called when the activity is first created. */
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+		if (savedInstanceState == null)
+		{
+			Intent ListIntent = new Intent(this, NativeListView.class);
+			startActivityForResult(ListIntent, 1);
+			
+			// Make the assets directory
+			String strDir = Environment.getExternalStorageDirectory()+File.separator+"dolphin-emu";
+			File directory = new File(strDir);
+			directory.mkdirs();
+			
+			strDir += File.separator+"Config";
+			directory = new File(strDir);
+			directory.mkdirs();
+			
+			// Copy assets if needed
+			java.io.File file = new java.io.File(
+					Environment.getExternalStorageDirectory()+File.separator+"dolphin-emu" + File.separator + "NoBanner.png");
+			if(!file.exists())
+			{
+				CopyAsset("ButtonA.png", 
+						Environment.getExternalStorageDirectory()+File.separator+
+						"dolphin-emu" + File.separator + "ButtonA.png");
+				CopyAsset("ButtonB.png", 
+						Environment.getExternalStorageDirectory()+File.separator+
+						"dolphin-emu" + File.separator + "ButtonB.png");
+				CopyAsset("ButtonStart.png", 
+						Environment.getExternalStorageDirectory()+File.separator+
+						"dolphin-emu" + File.separator + "ButtonStart.png");
+				CopyAsset("NoBanner.png", 
+						Environment.getExternalStorageDirectory()+File.separator+
+						"dolphin-emu" + File.separator + "NoBanner.png");
+				CopyAsset("Dolphin.png", 
+						Environment.getExternalStorageDirectory()+File.separator+
+						"dolphin-emu" + File.separator + "Dolphin.png");
+				CopyAsset("GCPadNew.ini", 
+						Environment.getExternalStorageDirectory()+File.separator+
+						"dolphin-emu" + File.separator +"Config"+ File.separator +"GCPadNew.ini");
+			}
+		}
+	}
+	
+	@Override
+	public void onActivityResult(int requestCode, int resultCode, Intent data)
+	{
+		super.onActivityResult(requestCode, resultCode, data);
+		
+		if (resultCode == Activity.RESULT_OK)
+		{
+			DisplayMetrics displayMetrics = new DisplayMetrics();
+			WindowManager wm = (WindowManager) getApplicationContext().getSystemService(getApplicationContext().WINDOW_SERVICE); // the results will be higher than using the activity context object or the getWindowManager() shortcut
+			wm.getDefaultDisplay().getMetrics(displayMetrics);
+			screenWidth = displayMetrics.widthPixels;
+			screenHeight = displayMetrics.heightPixels;
+			
+			String FileName = data.getStringExtra("Select");
+			GLview = new NativeGLSurfaceView(this);
+			//this.getWindow().setUiOptions(View.SYSTEM_UI_FLAG_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_FULLSCREEN, View.SYSTEM_UI_FLAG_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_FULLSCREEN);
+			GLview.SetDimensions(screenWidth, screenHeight);
+			GLview.SetFileName(FileName);
+			setContentView(GLview);
+			Running = true;
+		}
+	}
+	
+	@Override
+	public boolean onTouchEvent(MotionEvent event)
+	{
+		float X, Y;
+		int Action;
+		X = event.getX();
+		Y = event.getY();
+		Action = event.getActionMasked();
+		
+		// Converts button locations 0 - 1 to OGL screen coords -1.0 - 1.0
+		float ScreenX = ((X / screenWidth) * 2.0f) - 1.0f;
+		float ScreenY = ((Y / screenHeight) * -2.0f) + 1.0f;
+
+		onTouchEvent(Action, ScreenX, ScreenY);
+		
+		return false;
+	}
+	
+	public boolean overrideKeys()
+	{   
+		return false;
+	}  
+
+}                                

Source/Android/src/org/dolphinemu/dolphinemu/FileArrayAdapter.java

@@ -0,0 +1,53 @@
+package org.dolphinemu.dolphinemu;
+
+import java.util.List;
+
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ArrayAdapter;
+import android.widget.TextView;
+
+public class FileArrayAdapter extends ArrayAdapter<Option>{
+
+	private Context c;
+	private int id;
+	private List<Option>items;
+	
+	public FileArrayAdapter(Context context, int textViewResourceId,
+			List<Option> objects) {
+		super(context, textViewResourceId, objects);
+		c = context;
+		id = textViewResourceId;
+		items = objects;
+	}
+	public Option getItem(int i)
+	 {
+		 return items.get(i);
+	 }
+	 @Override
+      public View getView(int position, View convertView, ViewGroup parent) {
+              View v = convertView;
+              if (v == null) {
+                  LayoutInflater vi = (LayoutInflater)c.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+                  v = vi.inflate(id, null);
+              }
+              final Option o = items.get(position);
+              if (o != null) {
+                      TextView t1 = (TextView) v.findViewById(R.id.TextView01);
+                      TextView t2 = (TextView) v.findViewById(R.id.TextView02);
+                      
+                      if(t1!=null)
+                      	t1.setText(o.getName());
+                      if(t2!=null)
+                      	t2.setText(o.getData());
+                      
+              }
+              return v;
+      }
+
+
+
+}
+

Source/Android/src/org/dolphinemu/dolphinemu/NativeGLSurfaceView.java

@@ -0,0 +1,81 @@
+package org.dolphinemu.dolphinemu;
+
+import android.content.Context;
+import android.opengl.GLSurfaceView;
+import android.util.Log;
+import android.view.Surface;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+
+public class NativeGLSurfaceView extends SurfaceView {
+	static private String FileName;
+	static private Thread myRun;
+	static private boolean Running = false;
+	static private boolean Created = false;
+	static private float width;
+	static private float height;
+	
+	public static native void main(String File, Surface surf, int width, int height);
+	public static native void UnPauseEmulation();
+	public static native void PauseEmulation();
+	public static native void StopEmulation();
+	
+	static
+	{
+		try
+		{
+			System.loadLibrary("dolphin-emu-nogui"); 
+		}
+		catch (Exception ex)
+		{
+			Log.w("me", ex.toString());
+		}
+	}
+
+	public NativeGLSurfaceView(Context context) {
+		super(context);
+		if (!Created)
+		{
+			myRun = new Thread() 
+			{
+				@Override
+	      		public void run() {
+	    	  		main(FileName, getHolder().getSurface(), (int)width, (int)height);
+	      		}	
+			};
+			getHolder().addCallback(new SurfaceHolder.Callback() {
+		            public void surfaceCreated(SurfaceHolder holder) {
+		                // TODO Auto-generated method stub
+		            	if (!Running)
+		            	{
+		            		myRun.start();
+		            		Running = true;
+		            	}
+		            }
+
+					public void surfaceChanged(SurfaceHolder arg0, int arg1,
+							int arg2, int arg3) {
+						// TODO Auto-generated method stub
+						
+					}
+
+					public void surfaceDestroyed(SurfaceHolder arg0) {
+						// TODO Auto-generated method stub
+						
+					}
+			 });
+			Created = true;
+		}
+	}
+	
+	public void SetFileName(String file)
+	{
+		FileName = file;
+	}
+	
+	public void SetDimensions(float screenWidth, float screenHeight)
+	{
+		width = screenWidth;
+		height = screenHeight;
+	}
+}

Source/Android/src/org/dolphinemu/dolphinemu/NativeListView.java

@@ -0,0 +1,94 @@
+package org.dolphinemu.dolphinemu;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import android.app.Activity;
+import android.app.ListActivity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.Environment;
+import android.view.View;
+import android.widget.ListView;
+import android.widget.Toast;
+
+public class NativeListView extends ListActivity {
+	private FileArrayAdapter adapter;
+	private static File currentDir = null;
+	
+	private void Fill(File f)
+    {
+		File[]dirs = f.listFiles();
+		this.setTitle("Current Dir: " + f.getName());
+		List<Option>dir = new ArrayList<Option>();
+		List<Option>fls = new ArrayList<Option>();
+         
+		try
+		{
+			for(File ff: dirs)
+			{
+				if (ff.getName().charAt(0) != '.')
+					if(ff.isDirectory())
+						dir.add(new Option(ff.getName(),"Folder",ff.getAbsolutePath()));
+					else
+	                	if (ff.getName().toLowerCase().contains(".gcm") ||
+	                		ff.getName().toLowerCase().contains(".iso") ||
+	                		ff.getName().toLowerCase().contains(".wbfs") ||
+	                		ff.getName().toLowerCase().contains(".gcz") ||
+	                		ff.getName().toLowerCase().contains(".dol") ||
+	                		ff.getName().toLowerCase().contains(".elf"))
+	                			fls.add(new Option(ff.getName(),"File Size: "+ff.length(),ff.getAbsolutePath()));
+             }
+         }
+         catch(Exception e)
+         {
+         }
+         
+         Collections.sort(dir);
+         Collections.sort(fls);
+         dir.addAll(fls);
+         
+         if(!f.getName().equalsIgnoreCase("sdcard"))
+             dir.add(0,new Option("..","Parent Directory",f.getParent()));
+         adapter = new FileArrayAdapter(this,R.layout.main,dir);
+		 this.setListAdapter(adapter);
+    }
+	
+	@Override
+	protected void onListItemClick(ListView l, View v, int position, long id) {
+		// TODO Auto-generated method stub
+		super.onListItemClick(l, v, position, id);
+		Option o = adapter.getItem(position);
+		if(o.getData().equalsIgnoreCase("folder")||o.getData().equalsIgnoreCase("parent directory")){
+			currentDir = new File(o.getPath());
+			Fill(currentDir);
+		}
+		else
+		{
+			onFileClick(o.getPath());
+		}
+	}
+	
+	private void onFileClick(String o)
+    {
+    	Toast.makeText(this, "File Clicked: " + o, Toast.LENGTH_SHORT).show();
+    	
+        Intent intent = new Intent();
+        intent.putExtra("Select", o);
+        setResult(Activity.RESULT_OK, intent);
+        
+    	this.finish();
+    }
+	
+	@Override
+	public void onCreate(Bundle savedInstanceState) 
+	{
+		 super.onCreate(savedInstanceState);
+		 
+		 if(currentDir == null)
+			 currentDir = new File(Environment.getExternalStorageDirectory().getPath());
+	     Fill(currentDir);
+	}
+}

Source/Android/src/org/dolphinemu/dolphinemu/Option.java

@@ -0,0 +1,38 @@
+package org.dolphinemu.dolphinemu;
+
+public class Option implements Comparable<Option>{
+    private String name;
+    private String data;
+    private String path;
+    
+    public Option(String n,String d,String p)
+    {
+        name = n;
+        data = d;
+        path = p;
+    }
+    
+    public String getName()
+    {
+        return name;
+    }
+    
+    public String getData()
+    {
+        return data;
+    }
+    
+    public String getPath()
+    {
+        return path;
+    }
+    
+    public int compareTo(Option o) 
+    {
+        if(this.name != null)
+            return this.name.toLowerCase().compareTo(o.getName().toLowerCase()); 
+        else 
+            throw new IllegalArgumentException();
+    }
+}
+

Source/Core/AudioCommon/Src/AOSoundStream.cpp

@@ -1,19 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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 <functional>
 #include <string.h>

Source/Core/AudioCommon/Src/AOSoundStream.h

@@ -1,19 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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 _AOSOUNDSTREAM_H_
 #define _AOSOUNDSTREAM_H_

Source/Core/AudioCommon/Src/AudioCommon.cpp

@@ -1,19 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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 "AudioCommon.h"
 #include "FileUtil.h"

Source/Core/AudioCommon/Src/AudioCommon.h

@@ -1,19 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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 _AUDIO_COMMON_H_
 #define _AUDIO_COMMON_H_

Source/Core/AudioCommon/Src/DPL2Decoder.cpp

@@ -1,24 +1,11 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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/
 
 // Dolby Pro Logic 2 decoder from ffdshow-tryout
 //  * Copyright 2001 Anders Johansson ajh@atri.curtin.edu.au
 //  * Copyright (c) 2004-2006 Milan Cutka
-//	* based on mplayer HRTF plugin by ylai
+//  * based on mplayer HRTF plugin by ylai
 
 #include <functional>
 #include <vector>

Source/Core/AudioCommon/Src/DPL2Decoder.h

@@ -1,19 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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 _DPL2DECODER_H_
 #define _DPL2DECODER_H_

Source/Core/AudioCommon/Src/DSoundStream.cpp

@@ -1,19 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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 <cmath>
 #include <functional>

Source/Core/AudioCommon/Src/DSoundStream.h

@@ -1,19 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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 _DSOUNDSTREAM_H_
 #define _DSOUNDSTREAM_H_

Source/Core/AudioCommon/Src/Mixer.cpp

@@ -1,20 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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 "Atomic.h"
 #include "Mixer.h"

Source/Core/AudioCommon/Src/Mixer.h

@@ -1,19 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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 _MIXER_H_
 #define _MIXER_H_

Source/Core/AudioCommon/Src/NullSoundStream.cpp

@@ -1,19 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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 "AudioCommon.h"
 #include "NullSoundStream.h"

Source/Core/AudioCommon/Src/NullSoundStream.h

@@ -1,19 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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 _NULLSOUNDSTREAM_H_
 #define _NULLSOUNDSTREAM_H_

Source/Core/AudioCommon/Src/OpenALStream.cpp

@@ -1,19 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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 "aldlist.h"
 #include "OpenALStream.h"
@@ -72,7 +59,7 @@ bool OpenALStream::Start()
 		PanicAlertT("OpenAL: can't find sound devices");
 	}
 
-	// Initialise DPL2 parameters
+	// Initialize DPL2 parameters
 	dpl2reset();
 
 	soundTouch.clear();

Source/Core/AudioCommon/Src/OpenALStream.h

@@ -1,19 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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 _OPENALSTREAM_H_
 #define _OPENALSTREAM_H_

Source/Core/AudioCommon/Src/SoundStream.h

@@ -1,19 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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 _SOUNDSTREAM_H_
 #define _SOUNDSTREAM_H_

Source/Core/AudioCommon/Src/WaveFile.cpp

@@ -1,19 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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 "WaveFile.h"

Source/Core/AudioCommon/Src/WaveFile.h

@@ -1,19 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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/
 
 // ---------------------------------------------------------------------------------
 // Class: WaveFileWriter

Source/Core/AudioCommon/Src/XAudio2Stream.cpp

@@ -1,19 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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 "AudioCommon.h"
 #include "XAudio2Stream.h"
@@ -107,7 +94,7 @@ bool XAudio2::Start()
 {
 	HRESULT hr;
 
-	// callback dosent seem to run on a speecific cpu anyways
+	// callback doesn't seem to run on a specific cpu anyways
 	IXAudio2* xaudptr;
 	if (FAILED(hr = XAudio2Create(&xaudptr, 0, XAUDIO2_DEFAULT_PROCESSOR)))
 	{

Source/Core/AudioCommon/Src/XAudio2Stream.h

@@ -1,19 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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 _XAUDIO2STREAM_H_
 #define _XAUDIO2STREAM_H_

Source/Core/Common/Src/ArmEmitter.cpp

@@ -83,6 +83,40 @@ bool TryMakeOperand2_AllowNegation(s32 imm, Operand2 &op2, bool *negated)
 	}
 }
 
+Operand2 AssumeMakeOperand2(u32 imm) {
+	Operand2 op2;
+	bool result = TryMakeOperand2(imm, op2);
+	_dbg_assert_msg_(JIT, result, "Could not make assumed Operand2.");
+	return op2;
+}
+
+bool ARMXEmitter::TrySetValue_TwoOp(ARMReg reg, u32 val)
+{
+	int ops = 0;
+	for (int i = 0; i < 16; i++)
+	{
+		if ((val >> (i*2)) & 0x3)
+		{
+			ops++;
+			i+=3;
+		}
+	}
+	if (ops > 2)
+		return false;
+	
+	bool first = true;
+	for (int i = 0; i < 16; i++, val >>=2) {
+		if (val & 0x3) {
+			first ? MOV(reg, Operand2((u8)val, (u8)((16-i) & 0xF)))
+				  : ORR(reg, reg, Operand2((u8)val, (u8)((16-i) & 0xF)));
+			first = false;
+			i+=3;
+			val >>= 6;
+		}
+	}
+	return true;
+}
+
 void ARMXEmitter::MOVI2F(ARMReg dest, float val, ARMReg tempReg)
 {
 	union {float f; u32 u;} conv;
@@ -93,6 +127,21 @@ void ARMXEmitter::MOVI2F(ARMReg dest, float val, ARMReg tempReg)
 	// Otherwise, use a literal pool and VLDR directly (+- 1020)
 }
 
+void ARMXEmitter::ADDI2R(ARMReg rd, ARMReg rs, u32 val, ARMReg scratch)
+{
+	Operand2 op2;
+	bool negated;
+	if (TryMakeOperand2_AllowNegation(val, op2, &negated)) {
+		if (!negated)
+			ADD(rd, rs, op2);
+		else
+			SUB(rd, rs, op2);
+	} else {
+		MOVI2R(scratch, val);
+		ADD(rd, rs, scratch);
+	}
+}
+
 void ARMXEmitter::ANDI2R(ARMReg rd, ARMReg rs, u32 val, ARMReg scratch)
 {
 	Operand2 op2;
@@ -109,6 +158,21 @@ void ARMXEmitter::ANDI2R(ARMReg rd, ARMReg rs, u32 val, ARMReg scratch)
 	}
 }
 
+void ARMXEmitter::CMPI2R(ARMReg rs, u32 val, ARMReg scratch)
+{
+	Operand2 op2;
+	bool negated;
+	if (TryMakeOperand2_AllowNegation(val, op2, &negated)) {
+		if (!negated)
+			CMP(rs, op2);
+		else
+			CMN(rs, op2);
+	} else {
+		MOVI2R(scratch, val);
+		CMP(rs, scratch);
+	}
+}
+
 void ARMXEmitter::ORI2R(ARMReg rd, ARMReg rs, u32 val, ARMReg scratch)
 {
 	Operand2 op2;
@@ -173,7 +237,7 @@ void ARMXEmitter::MOVI2R(ARMReg reg, u32 val, bool optimize)
 			MOVW(reg, val & 0xFFFF);
 			if(val & 0xFFFF0000)
 				MOVT(reg, val, true);
-		} else {
+		} else if (!TrySetValue_TwoOp(reg,val)) {
 			// Use literal pool for ARMv6.
 			AddNewLit(val);
 			LDR(reg, _PC); // To be backpatched later
@@ -190,9 +254,7 @@ void ARMXEmitter::SetCodePtr(u8 *ptr)
 {
 	code = ptr;
 	startcode = code;
-#ifdef IOS
 	lastCacheFlushEnd = ptr;
-#endif
 }
 
 const u8 *ARMXEmitter::GetCodePtr() const
@@ -236,14 +298,15 @@ void ARMXEmitter::FlushIcacheSection(u8 *start, u8 *end)
 #elif defined(BLACKBERRY)
 	msync(start, end - start, MS_SYNC | MS_INVALIDATE_ICACHE);
 #elif defined(IOS)
-	if (start != NULL)
+	// Header file says this is equivalent to: sys_icache_invalidate(start, end - start);
-		sys_cache_control(kCacheFunctionPrepareForExecution, start, end - start);
+	sys_cache_control(kCacheFunctionPrepareForExecution, start, end - start);
 #elif !defined(_WIN32)
-#ifndef ANDROID
+#ifdef __clang__
-	start = startcode; // Should be Linux Only
+	__clear_cache(start, end);
-#endif
+#else
 	__builtin___clear_cache(start, end);
 #endif
+#endif
 }
 
 void ARMXEmitter::SetCC(CCFlags cond)
@@ -628,38 +691,40 @@ void ARMXEmitter::SVC(Operand2 op)
 
 // IMM, REG, IMMSREG, RSR
 // -1 for invalid if the instruction doesn't support that
-const s32 LoadStoreOps[][4] = { {0x40, 0x60, 0x60, -1}, // STR
+const s32 LoadStoreOps[][4] = {
-				{0x41, 0x61, 0x61, -1}, // LDR
+	{0x40, 0x60, 0x60, -1}, // STR
-				{0x44, 0x64, 0x64, -1}, // STRB
+	{0x41, 0x61, 0x61, -1}, // LDR
-				{0x45, 0x65, 0x65, -1}, // LDRB
+	{0x44, 0x64, 0x64, -1}, // STRB
-				// Special encodings
+	{0x45, 0x65, 0x65, -1}, // LDRB
-				{ 0x4,  0x0,  -1, -1}, // STRH
+	// Special encodings
-				{ 0x5,  0x1,  -1, -1}, // LDRH
+	{ 0x4,  0x0,  -1, -1}, // STRH
-				{ 0x5,  0x1,  -1, -1}, // LDRSB
+	{ 0x5,  0x1,  -1, -1}, // LDRH
-				{ 0x5,  0x1,  -1, -1}, // LDRSH
+	{ 0x5,  0x1,  -1, -1}, // LDRSB
-				};
+	{ 0x5,  0x1,  -1, -1}, // LDRSH
-const char *LoadStoreNames[] = { "STR",
+};
-				 "LDR",
+const char *LoadStoreNames[] = {
-				 "STRB",
+	"STR",
-				 "LDRB",
+	"LDR",
-				 "STRH",
+	"STRB",
-				 "LDRH",
+	"LDRB",
-				 "LDRSB",
+	"STRH",
-				 "LDRSH",
+	"LDRH",
-				};
+	"LDRSB",
+	"LDRSH",
+};
 
 void ARMXEmitter::WriteStoreOp(u32 Op, ARMReg Rt, ARMReg Rn, Operand2 Rm, bool RegAdd)
 {
 	s32 op = LoadStoreOps[Op][Rm.GetType()]; // Type always decided by last operand
 	u32 Data;
-	
+
 	// Qualcomm chipsets get /really/ angry if you don't use index, even if the offset is zero.
 	// Some of these encodings require Index at all times anyway. Doesn't really matter.
 	// bool Index = op2 != 0 ? true : false;
 	bool Index = true;
-	bool Add = false; 	
+	bool Add = false;
 
-	// Special Encoding	
+	// Special Encoding (misc addressing mode)
 	bool SpecialOp = false;
 	bool Half = false;
 	bool SignedLoad = false;
@@ -699,10 +764,13 @@ void ARMXEmitter::WriteStoreOp(u32 Op, ARMReg Rt, ARMReg Rn, Operand2 Rm, bool R
 			// The offset is encoded differently on this one.
 			if (SpecialOp)
 				Data = (Data & 0xF0 << 4) | (Data & 0xF);
-			if (Temp >= 0) Add = true;	
+			if (Temp >= 0) Add = true;
 		}
 		break;
 		case TYPE_REG:
+			Data = Rm.GetData();
+			Add = RegAdd;
+			break;
 		case TYPE_IMMSREG:
 			if (!SpecialOp)
 			{
@@ -710,17 +778,18 @@ void ARMXEmitter::WriteStoreOp(u32 Op, ARMReg Rt, ARMReg Rn, Operand2 Rm, bool R
 				Add = RegAdd;
 				break;
 			}
+			// Intentional fallthrough: TYPE_IMMSREG not supported for misc addressing.
 		default:
 			// RSR not supported for any of these
 			// We already have the warning above
 			BKPT(0x2);
 			return;
-		break;  
+		break;
 	}
 	if (SpecialOp)
 	{
 		// Add SpecialOp things
-		Data = (0x5 << 4) | (SignedLoad << 6) | (Half << 5) | Data;
+		Data = (0x9 << 4) | (SignedLoad << 6) | (Half << 5) | Data;
 	}
 	Write32(condition | (op << 20) | (Index << 24) | (Add << 23) | (Rn << 16) | (Rt << 12) | Data);
 }
@@ -947,7 +1016,6 @@ void ARMXEmitter::VLDR(ARMReg Dest, ARMReg Base, s16 offset)
 	{
 		Write32(condition | (0xD << 24) | (Add << 23) | ((Dest & 0x1) << 22) | (1 << 20) | (Base << 16) \
 			| ((Dest & 0x1E) << 11) | (10 << 8) | (imm >> 2));	
-
 	}
 	else
 	{

Source/Core/Common/Src/ArmEmitter.h

@@ -320,6 +320,9 @@ bool TryMakeOperand2(u32 imm, Operand2 &op2);
 bool TryMakeOperand2_AllowInverse(u32 imm, Operand2 &op2, bool *inverse);
 bool TryMakeOperand2_AllowNegation(s32 imm, Operand2 &op2, bool *negated);
 
+// Use this only when you know imm can be made into an Operand2.
+Operand2 AssumeMakeOperand2(u32 imm);
+
 inline Operand2 R(ARMReg Reg)	{ return Operand2(Reg, TYPE_REG); }
 inline Operand2 IMM(u32 Imm)	{ return Operand2(Imm, TYPE_IMM); }
 inline Operand2 Mem(void *ptr)	{ return Operand2((u32)ptr, TYPE_IMM); }
@@ -394,6 +397,7 @@ public:
 
 	void FlushLitPool();
 	void AddNewLit(u32 val);
+	bool TrySetValue_TwoOp(ARMReg reg, u32 val);
 
 	CCFlags GetCC() { return CCFlags(condition >> 28); }
 	void SetCC(CCFlags cond = CC_AL);
@@ -562,7 +566,9 @@ public:
 	void MOVI2R(ARMReg reg, u32 val, bool optimize = true);
 	void MOVI2F(ARMReg dest, float val, ARMReg tempReg);
 
+	void ADDI2R(ARMReg rd, ARMReg rs, u32 val, ARMReg scratch);
 	void ANDI2R(ARMReg rd, ARMReg rs, u32 val, ARMReg scratch);
+	void CMPI2R(ARMReg rs, u32 val, ARMReg scratch);
 	void ORI2R(ARMReg rd, ARMReg rs, u32 val, ARMReg scratch);
 
 

Source/Core/Common/Src/Atomic.h

@@ -1,19 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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 _ATOMIC_H_
 #define _ATOMIC_H_

Source/Core/Common/Src/Atomic_GCC.h

@@ -1,19 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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 _ATOMIC_GCC_H_
 #define _ATOMIC_GCC_H_

Source/Core/Common/Src/Atomic_Win32.h

@@ -1,19 +1,6 @@
-// Copyright (C) 2003 Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
-
+// Licensed under GPLv2
-// This program is free software: you can redistribute it and/or modify
+// Refer to the license.txt file included.
-// 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 _ATOMIC_WIN32_H_
 #define _ATOMIC_WIN32_H_