Merge pull request #1238 from tambry/CoverityFix

Fix Coverity and bump the version.

.gitignore

@@ -9,21 +9,70 @@
 # Compiled Static libraries
 *.lai
 *.la
-*.a
-/libs
+# *.a # Commented out since OpenAL Soft's binaries use this extension.
 *.opensdf
 *.sdf
-*.user
-/bin/rpcs3.exe
-/bin/RPCS3.log
-/bin/rpcs3.ini
-/bin/compiled.elf
-/bin/FragmentProgram.txt
-/bin/VertexDataArray.dump
-/bin/VertexProgram.txt
-/bin/BreakPoints.dat
-/bin/textures
 *.suo
+*.tlog
+*.idb
+*.pdb
+*.obj
+*.ilk
+*.pch
+
+*.log
+*.exe
+*.dll
+*.elf
+*.lastbuildstate
+*.unsuccessfulbuild
+*.res
+*.dump
+*.wav
+
+/build
+/bin
+/libs
+/ipch
 /rpcs3/Debug
 /rpcs3/Release
-/ipch
+/llvm_build
+
+/wxWidgets/lib
+/bin/rpcs3.ini
+/bin/rpcs3.ipdb
+/bin/rpcs3.iobj
+/bin/FragmentProgram.txt
+/bin/VertexProgram.txt
+/bin/*.hlsl
+/bin/BreakPoints.dat
+/bin/textures
+/bin/*.lib
+/bin/*.exp
+rpcs3/git-version.h
+
+# Visual Studio Profiler Files
+*.vspx
+*.psess
+
+# Copyrighted files
+/bin/data/
+/bin/dev_flash/data/font
+/bin/dev_flash/sys
+/bin/dev_flash/vsh
+
+# Ignore installed games except test homebrews
+!/bin/dev_hdd0/game/
+/bin/dev_hdd0/game/*
+!/bin/dev_hdd0/game/TEST12345/
+
+# Ignore other system generated files
+bin/dev_hdd0/*.txt
+x64/*
+rpcs3/x64/*
+
+.DS_Store
+rpcs3/Emu/SysCalls/Modules/prx_*.h
+
+/CMakeFiles/
+CMakeCache.txt

.gitmodules

@@ -0,0 +1,17 @@
+[submodule "wxWidgets"]
+	path = wxWidgets
+	url = https://github.com/wxWidgets/wxWidgets
+	ignore = dirty
+[submodule "rpcs3-ffmpeg"]
+	path = ffmpeg
+	url = https://github.com/hrydgard/ppsspp-ffmpeg
+[submodule "asmjit"]
+	path = asmjit
+	url = https://github.com/kobalicek/asmjit
+[submodule "llvm"]
+	path = llvm
+	url = https://github.com/llvm-mirror/llvm
+	branch = release_36
+[submodule "minidx9"]
+	path = minidx9
+	url = https://github.com/hrydgard/minidx9.git

.travis.yml

@@ -0,0 +1,107 @@
+language: cpp
+
+os:
+ - linux
+ - osx
+
+osx_image: xcode6.4
+
+compiler:
+ - clang
+ - gcc
+
+env:
+  global:
+   - secure: "jA29KvTCTR7q4BMzPPUBGazjJwrIWa7k4fo5ZSMlyxh2NbztZTKQYwodgDcXBoptCd1KJ9H3FXwBnNdMNVnTkvoPL9uWnN4K/3D1D20FCag1kmlBwnaVqVei5cRiZ9TOMuaxhjkdg8pcrQLTlXEEdMZf6A2OW0VgoBGDVSX9nYc="
+   # Which Travis environment to run Coverity on
+   - coverity_scan_run_condition='"$CC" = gcc -a "$TRAVIS_OS_NAME" != osx'
+   # Test mode is for testing if it's working with Coverity. Change to true if testing, to avoid reaching the quota.
+   - coverity_scan_script_test_mode=false
+
+branches:
+  except:
+    - ppu_recompiler
+
+matrix:
+ exclude:
+  - os: osx
+    compiler: gcc
+
+git:
+  submodules: false
+
+before_install:
+# shutdown services on Travis, which may have a memory impact
+# show memory usage before and after shutdown of services
+  - if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+      sudo service --status-all;
+      sudo free -m -t;
+      sudo /etc/init.d/mysql stop;
+      sudo /etc/init.d/postgresql stop;
+      sudo /etc/init.d/couchdb stop;
+      sudo /etc/init.d/redis-server stop;
+      sudo free -m -t;
+
+      echo "yes" | sudo apt-key adv --fetch-keys 'http://repos.codelite.org/CodeLite.asc';
+      echo "yes" | sudo apt-add-repository 'deb http://repos.codelite.org/wx3.0/ubuntu/ precise universe';
+      echo "yes" | sudo add-apt-repository 'deb http://ppa.launchpad.net/ubuntu-toolchain-r/test/ubuntu precise main';
+      echo "yes" | sudo add-apt-repository 'deb http://llvm.org/apt/precise/ llvm-toolchain-precise-3.6 main';
+      wget -O - http://llvm.org/apt/llvm-snapshot.gpg.key | sudo apt-key add -;
+      sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y;
+      sudo apt-get update;
+      sudo apt-get install libwxgtk3.0-dev libopenal-dev freeglut3-dev libglew-dev libc6-dev llvm-3.6 llvm-3.6-dev libedit-dev;
+      sudo apt-get install aria2 -qq;
+      download_extract() { aria2c -x 16 $1 -o $2 && tar -xf $2; };
+    fi;
+  - if [ "$TRAVIS_OS_NAME" = "linux" ] && [ "$CXX" = "g++" ]; then
+      sudo apt-get install -qq g++-4.9;
+      export CXX="g++-4.9" CC="gcc-4.9" CXXFLAGS="-Wno-format-security";
+      export GCC_COLORS='error=01;31:warning=01;35:note=01;36:caret=01;32:locus=01:quote=01';
+    elif [ "$TRAVIS_OS_NAME" = "linux" ]; then
+      sudo apt-get install -qq --allow-unauthenticated clang-3.6 libstdc++-4.8-dev;
+      export CXX="clang++-3.6" CC="clang-3.6";
+    fi;
+# Travis uses CMake 2.8.7. We require 2.8.8. Grab latest
+# Add coverall for C++ so coverall.io could be triggered. Even it should be --coverage and gcov.
+  - if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+      sudo apt-get install lib32stdc++6 -qq &&
+      aria2c -x 16 http://www.cmake.org/files/v3.0/cmake-3.0.0-Linux-i386.sh && 
+      chmod a+x cmake-3.0.0-Linux-i386.sh &&
+      sudo ./cmake-3.0.0-Linux-i386.sh --skip-license --prefix=/usr;
+      sudo pip install cpp-coveralls;
+    else
+      brew update; brew update;
+      brew install glew wxwidgets llvm36;
+    fi;
+
+before_script:
+ - git submodule update --init asmjit ffmpeg
+ - mkdir build
+ - cd build
+ - if [ "$TRAVIS_OS_NAME" = "linux" ]; then cmake ..; else cmake .. -DLLVM_DIR=/usr/local/opt/llvm36/lib/llvm-3.6/share/llvm/cmake; fi
+
+script:
+# Add a command to show all the variables. May be useful for debugging Travis.
+# - echo "--Shell Export Lists START--" ; export -p; echo "--Shell Export Lists STOP--";
+# And to ensure the versions of toolchain
+- echo "--CXX version?"; "$CXX" --version; echo "--CXX version confirmed";
+- if [ "$COVERITY_SCAN_BRANCH" != 1 ]; then make -j 4; fi
+
+addons:
+  coverity_scan:
+    project:
+      name: $TRAVIS_REPO_SLUG
+    notification_email: raul.tambre@gmail.com
+    build_command_prepend: ""
+    build_command:   "make -j 4"
+    branch_pattern: master
+
+after_success:
+- coveralls --extension .c --extension .cpp --extension .h;
+
+after_failure:
+# show memory usage again and show actions of the OOM killer
+ - if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+     sudo free -m -t;
+     sudo dmesg;
+   fi;

CMakeLists.txt

@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 2.8.12)
+
+set(ASMJIT_STATIC TRUE)
+
+if (NOT CMAKE_BUILD_TYPE)
+	message(STATUS "No build type selected, default to Release")
+	set(CMAKE_BUILD_TYPE "Release")
+endif()
+
+if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
+	message( FATAL_ERROR "RPCS3 can only be compiled on 64-bit platforms." )
+endif()
+
+add_subdirectory( asmjit )
+# TODO: do real installation, including copying directory structure
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE "${PROJECT_BINARY_DIR}/bin")
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG "${PROJECT_BINARY_DIR}/bin")
+add_subdirectory( rpcs3 )

LICENSE

@@ -0,0 +1,339 @@
+GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc., <http://fsf.org/>
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    {description}
+    Copyright (C) {year}  {fullname}
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    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 for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  {signature of Ty Coon}, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

OpenAL/include/al.h

@@ -0,0 +1,656 @@
+#ifndef AL_AL_H
+#define AL_AL_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#ifndef AL_API
+ #if defined(AL_LIBTYPE_STATIC)
+  #define AL_API
+ #elif defined(_WIN32)
+  #define AL_API __declspec(dllimport)
+ #else
+  #define AL_API extern
+ #endif
+#endif
+
+#if defined(_WIN32)
+ #define AL_APIENTRY __cdecl
+#else
+ #define AL_APIENTRY
+#endif
+
+
+/** Deprecated macro. */
+#define OPENAL
+#define ALAPI                                    AL_API
+#define ALAPIENTRY                               AL_APIENTRY
+#define AL_INVALID                               (-1)
+#define AL_ILLEGAL_ENUM                          AL_INVALID_ENUM
+#define AL_ILLEGAL_COMMAND                       AL_INVALID_OPERATION
+
+/** Supported AL version. */
+#define AL_VERSION_1_0
+#define AL_VERSION_1_1
+
+/** 8-bit boolean */
+typedef char ALboolean;
+
+/** character */
+typedef char ALchar;
+
+/** signed 8-bit 2's complement integer */
+typedef signed char ALbyte;
+
+/** unsigned 8-bit integer */
+typedef unsigned char ALubyte;
+
+/** signed 16-bit 2's complement integer */
+typedef short ALshort;
+
+/** unsigned 16-bit integer */
+typedef unsigned short ALushort;
+
+/** signed 32-bit 2's complement integer */
+typedef int ALint;
+
+/** unsigned 32-bit integer */
+typedef unsigned int ALuint;
+
+/** non-negative 32-bit binary integer size */
+typedef int ALsizei;
+
+/** enumerated 32-bit value */
+typedef int ALenum;
+
+/** 32-bit IEEE754 floating-point */
+typedef float ALfloat;
+
+/** 64-bit IEEE754 floating-point */
+typedef double ALdouble;
+
+/** void type (for opaque pointers only) */
+typedef void ALvoid;
+
+
+/* Enumerant values begin at column 50. No tabs. */
+
+/** "no distance model" or "no buffer" */
+#define AL_NONE                                  0
+
+/** Boolean False. */
+#define AL_FALSE                                 0
+
+/** Boolean True. */
+#define AL_TRUE                                  1
+
+
+/**
+ * Relative source.
+ * Type:    ALboolean
+ * Range:   [AL_TRUE, AL_FALSE]
+ * Default: AL_FALSE
+ *
+ * Specifies if the Source has relative coordinates.
+ */
+#define AL_SOURCE_RELATIVE                       0x202
+
+
+/**
+ * Inner cone angle, in degrees.
+ * Type:    ALint, ALfloat
+ * Range:   [0 - 360]
+ * Default: 360
+ *
+ * The angle covered by the inner cone, where the source will not attenuate.
+ */
+#define AL_CONE_INNER_ANGLE                      0x1001
+
+/**
+ * Outer cone angle, in degrees.
+ * Range:   [0 - 360]
+ * Default: 360
+ *
+ * The angle covered by the outer cone, where the source will be fully
+ * attenuated.
+ */
+#define AL_CONE_OUTER_ANGLE                      0x1002
+
+/**
+ * Source pitch.
+ * Type:    ALfloat
+ * Range:   [0.5 - 2.0]
+ * Default: 1.0
+ *
+ * A multiplier for the frequency (sample rate) of the source's buffer.
+ */
+#define AL_PITCH                                 0x1003
+
+/**
+ * Source or listener position.
+ * Type:    ALfloat[3], ALint[3]
+ * Default: {0, 0, 0}
+ *
+ * The source or listener location in three dimensional space.
+ *
+ * OpenAL, like OpenGL, uses a right handed coordinate system, where in a
+ * frontal default view X (thumb) points right, Y points up (index finger), and
+ * Z points towards the viewer/camera (middle finger).
+ *
+ * To switch from a left handed coordinate system, flip the sign on the Z
+ * coordinate.
+ */
+#define AL_POSITION                              0x1004
+
+/**
+ * Source direction.
+ * Type:    ALfloat[3], ALint[3]
+ * Default: {0, 0, 0}
+ *
+ * Specifies the current direction in local space.
+ * A zero-length vector specifies an omni-directional source (cone is ignored).
+ */
+#define AL_DIRECTION                             0x1005
+
+/**
+ * Source or listener velocity.
+ * Type:    ALfloat[3], ALint[3]
+ * Default: {0, 0, 0}
+ *
+ * Specifies the current velocity in local space.
+ */
+#define AL_VELOCITY                              0x1006
+
+/**
+ * Source looping.
+ * Type:    ALboolean
+ * Range:   [AL_TRUE, AL_FALSE]
+ * Default: AL_FALSE
+ *
+ * Specifies whether source is looping.
+ */
+#define AL_LOOPING                               0x1007
+
+/**
+ * Source buffer.
+ * Type:  ALuint
+ * Range: any valid Buffer.
+ *
+ * Specifies the buffer to provide sound samples.
+ */
+#define AL_BUFFER                                0x1009
+
+/**
+ * Source or listener gain.
+ * Type:  ALfloat
+ * Range: [0.0 - ]
+ *
+ * A value of 1.0 means unattenuated. Each division by 2 equals an attenuation
+ * of about -6dB. Each multiplicaton by 2 equals an amplification of about
+ * +6dB.
+ *
+ * A value of 0.0 is meaningless with respect to a logarithmic scale; it is
+ * silent.
+ */
+#define AL_GAIN                                  0x100A
+
+/**
+ * Minimum source gain.
+ * Type:  ALfloat
+ * Range: [0.0 - 1.0]
+ *
+ * The minimum gain allowed for a source, after distance and cone attenation is
+ * applied (if applicable).
+ */
+#define AL_MIN_GAIN                              0x100D
+
+/**
+ * Maximum source gain.
+ * Type:  ALfloat
+ * Range: [0.0 - 1.0]
+ *
+ * The maximum gain allowed for a source, after distance and cone attenation is
+ * applied (if applicable).
+ */
+#define AL_MAX_GAIN                              0x100E
+
+/**
+ * Listener orientation.
+ * Type: ALfloat[6]
+ * Default: {0.0, 0.0, -1.0, 0.0, 1.0, 0.0}
+ *
+ * Effectively two three dimensional vectors. The first vector is the front (or
+ * "at") and the second is the top (or "up").
+ *
+ * Both vectors are in local space.
+ */
+#define AL_ORIENTATION                           0x100F
+
+/**
+ * Source state (query only).
+ * Type:  ALint
+ * Range: [AL_INITIAL, AL_PLAYING, AL_PAUSED, AL_STOPPED]
+ */
+#define AL_SOURCE_STATE                          0x1010
+
+/** Source state value. */
+#define AL_INITIAL                               0x1011
+#define AL_PLAYING                               0x1012
+#define AL_PAUSED                                0x1013
+#define AL_STOPPED                               0x1014
+
+/**
+ * Source Buffer Queue size (query only).
+ * Type: ALint
+ *
+ * The number of buffers queued using alSourceQueueBuffers, minus the buffers
+ * removed with alSourceUnqueueBuffers.
+ */
+#define AL_BUFFERS_QUEUED                        0x1015
+
+/**
+ * Source Buffer Queue processed count (query only).
+ * Type: ALint
+ *
+ * The number of queued buffers that have been fully processed, and can be
+ * removed with alSourceUnqueueBuffers.
+ *
+ * Looping sources will never fully process buffers because they will be set to
+ * play again for when the source loops.
+ */
+#define AL_BUFFERS_PROCESSED                     0x1016
+
+/**
+ * Source reference distance.
+ * Type:    ALfloat
+ * Range:   [0.0 - ]
+ * Default: 1.0
+ *
+ * The distance in units that no attenuation occurs.
+ *
+ * At 0.0, no distance attenuation ever occurs on non-linear attenuation models.
+ */
+#define AL_REFERENCE_DISTANCE                    0x1020
+
+/**
+ * Source rolloff factor.
+ * Type:    ALfloat
+ * Range:   [0.0 - ]
+ * Default: 1.0
+ *
+ * Multiplier to exaggerate or diminish distance attenuation.
+ *
+ * At 0.0, no distance attenuation ever occurs.
+ */
+#define AL_ROLLOFF_FACTOR                        0x1021
+
+/**
+ * Outer cone gain.
+ * Type:    ALfloat
+ * Range:   [0.0 - 1.0]
+ * Default: 0.0
+ *
+ * The gain attenuation applied when the listener is outside of the source's
+ * outer cone.
+ */
+#define AL_CONE_OUTER_GAIN                       0x1022
+
+/**
+ * Source maximum distance.
+ * Type:    ALfloat
+ * Range:   [0.0 - ]
+ * Default: +inf
+ *
+ * The distance above which the source is not attenuated any further with a
+ * clamped distance model, or where attenuation reaches 0.0 gain for linear
+ * distance models with a default rolloff factor.
+ */
+#define AL_MAX_DISTANCE                          0x1023
+
+/** Source buffer position, in seconds */
+#define AL_SEC_OFFSET                            0x1024
+/** Source buffer position, in sample frames */
+#define AL_SAMPLE_OFFSET                         0x1025
+/** Source buffer position, in bytes */
+#define AL_BYTE_OFFSET                           0x1026
+
+/**
+ * Source type (query only).
+ * Type:  ALint
+ * Range: [AL_STATIC, AL_STREAMING, AL_UNDETERMINED]
+ *
+ * A Source is Static if a Buffer has been attached using AL_BUFFER.
+ *
+ * A Source is Streaming if one or more Buffers have been attached using
+ * alSourceQueueBuffers.
+ *
+ * A Source is Undetermined when it has the NULL buffer attached using
+ * AL_BUFFER.
+ */
+#define AL_SOURCE_TYPE                           0x1027
+
+/** Source type value. */
+#define AL_STATIC                                0x1028
+#define AL_STREAMING                             0x1029
+#define AL_UNDETERMINED                          0x1030
+
+/** Buffer format specifier. */
+#define AL_FORMAT_MONO8                          0x1100
+#define AL_FORMAT_MONO16                         0x1101
+#define AL_FORMAT_STEREO8                        0x1102
+#define AL_FORMAT_STEREO16                       0x1103
+
+/** Buffer frequency (query only). */
+#define AL_FREQUENCY                             0x2001
+/** Buffer bits per sample (query only). */
+#define AL_BITS                                  0x2002
+/** Buffer channel count (query only). */
+#define AL_CHANNELS                              0x2003
+/** Buffer data size (query only). */
+#define AL_SIZE                                  0x2004
+
+/**
+ * Buffer state.
+ *
+ * Not for public use.
+ */
+#define AL_UNUSED                                0x2010
+#define AL_PENDING                               0x2011
+#define AL_PROCESSED                             0x2012
+
+
+/** No error. */
+#define AL_NO_ERROR                              0
+
+/** Invalid name paramater passed to AL call. */
+#define AL_INVALID_NAME                          0xA001
+
+/** Invalid enum parameter passed to AL call. */
+#define AL_INVALID_ENUM                          0xA002
+
+/** Invalid value parameter passed to AL call. */
+#define AL_INVALID_VALUE                         0xA003
+
+/** Illegal AL call. */
+#define AL_INVALID_OPERATION                     0xA004
+
+/** Not enough memory. */
+#define AL_OUT_OF_MEMORY                         0xA005
+
+
+/** Context string: Vendor ID. */
+#define AL_VENDOR                                0xB001
+/** Context string: Version. */
+#define AL_VERSION                               0xB002
+/** Context string: Renderer ID. */
+#define AL_RENDERER                              0xB003
+/** Context string: Space-separated extension list. */
+#define AL_EXTENSIONS                            0xB004
+
+
+/**
+ * Doppler scale.
+ * Type:    ALfloat
+ * Range:   [0.0 - ]
+ * Default: 1.0
+ *
+ * Scale for source and listener velocities.
+ */
+#define AL_DOPPLER_FACTOR                        0xC000
+AL_API void AL_APIENTRY alDopplerFactor(ALfloat value);
+
+/**
+ * Doppler velocity (deprecated).
+ *
+ * A multiplier applied to the Speed of Sound.
+ */
+#define AL_DOPPLER_VELOCITY                      0xC001
+AL_API void AL_APIENTRY alDopplerVelocity(ALfloat value);
+
+/**
+ * Speed of Sound, in units per second.
+ * Type:    ALfloat
+ * Range:   [0.0001 - ]
+ * Default: 343.3
+ *
+ * The speed at which sound waves are assumed to travel, when calculating the
+ * doppler effect.
+ */
+#define AL_SPEED_OF_SOUND                        0xC003
+AL_API void AL_APIENTRY alSpeedOfSound(ALfloat value);
+
+/**
+ * Distance attenuation model.
+ * Type:    ALint
+ * Range:   [AL_NONE, AL_INVERSE_DISTANCE, AL_INVERSE_DISTANCE_CLAMPED,
+ *           AL_LINEAR_DISTANCE, AL_LINEAR_DISTANCE_CLAMPED,
+ *           AL_EXPONENT_DISTANCE, AL_EXPONENT_DISTANCE_CLAMPED]
+ * Default: AL_INVERSE_DISTANCE_CLAMPED
+ *
+ * The model by which sources attenuate with distance.
+ *
+ * None     - No distance attenuation.
+ * Inverse  - Doubling the distance halves the source gain.
+ * Linear   - Linear gain scaling between the reference and max distances.
+ * Exponent - Exponential gain dropoff.
+ *
+ * Clamped variations work like the non-clamped counterparts, except the
+ * distance calculated is clamped between the reference and max distances.
+ */
+#define AL_DISTANCE_MODEL                        0xD000
+AL_API void AL_APIENTRY alDistanceModel(ALenum distanceModel);
+
+/** Distance model value. */
+#define AL_INVERSE_DISTANCE                      0xD001
+#define AL_INVERSE_DISTANCE_CLAMPED              0xD002
+#define AL_LINEAR_DISTANCE                       0xD003
+#define AL_LINEAR_DISTANCE_CLAMPED               0xD004
+#define AL_EXPONENT_DISTANCE                     0xD005
+#define AL_EXPONENT_DISTANCE_CLAMPED             0xD006
+
+/** Renderer State management. */
+AL_API void AL_APIENTRY alEnable(ALenum capability);
+AL_API void AL_APIENTRY alDisable(ALenum capability);
+AL_API ALboolean AL_APIENTRY alIsEnabled(ALenum capability);
+
+/** State retrieval. */
+AL_API const ALchar* AL_APIENTRY alGetString(ALenum param);
+AL_API void AL_APIENTRY alGetBooleanv(ALenum param, ALboolean *values);
+AL_API void AL_APIENTRY alGetIntegerv(ALenum param, ALint *values);
+AL_API void AL_APIENTRY alGetFloatv(ALenum param, ALfloat *values);
+AL_API void AL_APIENTRY alGetDoublev(ALenum param, ALdouble *values);
+AL_API ALboolean AL_APIENTRY alGetBoolean(ALenum param);
+AL_API ALint AL_APIENTRY alGetInteger(ALenum param);
+AL_API ALfloat AL_APIENTRY alGetFloat(ALenum param);
+AL_API ALdouble AL_APIENTRY alGetDouble(ALenum param);
+
+/**
+ * Error retrieval.
+ *
+ * Obtain the first error generated in the AL context since the last check.
+ */
+AL_API ALenum AL_APIENTRY alGetError(void);
+
+/**
+ * Extension support.
+ *
+ * Query for the presence of an extension, and obtain any appropriate function
+ * pointers and enum values.
+ */
+AL_API ALboolean AL_APIENTRY alIsExtensionPresent(const ALchar *extname);
+AL_API void* AL_APIENTRY alGetProcAddress(const ALchar *fname);
+AL_API ALenum AL_APIENTRY alGetEnumValue(const ALchar *ename);
+
+
+/** Set Listener parameters */
+AL_API void AL_APIENTRY alListenerf(ALenum param, ALfloat value);
+AL_API void AL_APIENTRY alListener3f(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
+AL_API void AL_APIENTRY alListenerfv(ALenum param, const ALfloat *values);
+AL_API void AL_APIENTRY alListeneri(ALenum param, ALint value);
+AL_API void AL_APIENTRY alListener3i(ALenum param, ALint value1, ALint value2, ALint value3);
+AL_API void AL_APIENTRY alListeneriv(ALenum param, const ALint *values);
+
+/** Get Listener parameters */
+AL_API void AL_APIENTRY alGetListenerf(ALenum param, ALfloat *value);
+AL_API void AL_APIENTRY alGetListener3f(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
+AL_API void AL_APIENTRY alGetListenerfv(ALenum param, ALfloat *values);
+AL_API void AL_APIENTRY alGetListeneri(ALenum param, ALint *value);
+AL_API void AL_APIENTRY alGetListener3i(ALenum param, ALint *value1, ALint *value2, ALint *value3);
+AL_API void AL_APIENTRY alGetListeneriv(ALenum param, ALint *values);
+
+
+/** Create Source objects. */
+AL_API void AL_APIENTRY alGenSources(ALsizei n, ALuint *sources);
+/** Delete Source objects. */
+AL_API void AL_APIENTRY alDeleteSources(ALsizei n, const ALuint *sources);
+/** Verify a handle is a valid Source. */
+AL_API ALboolean AL_APIENTRY alIsSource(ALuint source);
+
+/** Set Source parameters. */
+AL_API void AL_APIENTRY alSourcef(ALuint source, ALenum param, ALfloat value);
+AL_API void AL_APIENTRY alSource3f(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
+AL_API void AL_APIENTRY alSourcefv(ALuint source, ALenum param, const ALfloat *values);
+AL_API void AL_APIENTRY alSourcei(ALuint source, ALenum param, ALint value);
+AL_API void AL_APIENTRY alSource3i(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3);
+AL_API void AL_APIENTRY alSourceiv(ALuint source, ALenum param, const ALint *values);
+
+/** Get Source parameters. */
+AL_API void AL_APIENTRY alGetSourcef(ALuint source, ALenum param, ALfloat *value);
+AL_API void AL_APIENTRY alGetSource3f(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
+AL_API void AL_APIENTRY alGetSourcefv(ALuint source, ALenum param, ALfloat *values);
+AL_API void AL_APIENTRY alGetSourcei(ALuint source,  ALenum param, ALint *value);
+AL_API void AL_APIENTRY alGetSource3i(ALuint source, ALenum param, ALint *value1, ALint *value2, ALint *value3);
+AL_API void AL_APIENTRY alGetSourceiv(ALuint source,  ALenum param, ALint *values);
+
+
+/** Play, replay, or resume (if paused) a list of Sources */
+AL_API void AL_APIENTRY alSourcePlayv(ALsizei n, const ALuint *sources);
+/** Stop a list of Sources */
+AL_API void AL_APIENTRY alSourceStopv(ALsizei n, const ALuint *sources);
+/** Rewind a list of Sources */
+AL_API void AL_APIENTRY alSourceRewindv(ALsizei n, const ALuint *sources);
+/** Pause a list of Sources */
+AL_API void AL_APIENTRY alSourcePausev(ALsizei n, const ALuint *sources);
+
+/** Play, replay, or resume a Source */
+AL_API void AL_APIENTRY alSourcePlay(ALuint source);
+/** Stop a Source */
+AL_API void AL_APIENTRY alSourceStop(ALuint source);
+/** Rewind a Source (set playback postiton to beginning) */
+AL_API void AL_APIENTRY alSourceRewind(ALuint source);
+/** Pause a Source */
+AL_API void AL_APIENTRY alSourcePause(ALuint source);
+
+/** Queue buffers onto a source */
+AL_API void AL_APIENTRY alSourceQueueBuffers(ALuint source, ALsizei nb, const ALuint *buffers);
+/** Unqueue processed buffers from a source */
+AL_API void AL_APIENTRY alSourceUnqueueBuffers(ALuint source, ALsizei nb, ALuint *buffers);
+
+
+/** Create Buffer objects */
+AL_API void AL_APIENTRY alGenBuffers(ALsizei n, ALuint *buffers);
+/** Delete Buffer objects */
+AL_API void AL_APIENTRY alDeleteBuffers(ALsizei n, const ALuint *buffers);
+/** Verify a handle is a valid Buffer */
+AL_API ALboolean AL_APIENTRY alIsBuffer(ALuint buffer);
+
+/** Specifies the data to be copied into a buffer */
+AL_API void AL_APIENTRY alBufferData(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei freq);
+
+/** Set Buffer parameters, */
+AL_API void AL_APIENTRY alBufferf(ALuint buffer, ALenum param, ALfloat value);
+AL_API void AL_APIENTRY alBuffer3f(ALuint buffer, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
+AL_API void AL_APIENTRY alBufferfv(ALuint buffer, ALenum param, const ALfloat *values);
+AL_API void AL_APIENTRY alBufferi(ALuint buffer, ALenum param, ALint value);
+AL_API void AL_APIENTRY alBuffer3i(ALuint buffer, ALenum param, ALint value1, ALint value2, ALint value3);
+AL_API void AL_APIENTRY alBufferiv(ALuint buffer, ALenum param, const ALint *values);
+
+/** Get Buffer parameters. */
+AL_API void AL_APIENTRY alGetBufferf(ALuint buffer, ALenum param, ALfloat *value);
+AL_API void AL_APIENTRY alGetBuffer3f(ALuint buffer, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
+AL_API void AL_APIENTRY alGetBufferfv(ALuint buffer, ALenum param, ALfloat *values);
+AL_API void AL_APIENTRY alGetBufferi(ALuint buffer, ALenum param, ALint *value);
+AL_API void AL_APIENTRY alGetBuffer3i(ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3);
+AL_API void AL_APIENTRY alGetBufferiv(ALuint buffer, ALenum param, ALint *values);
+
+/** Pointer-to-function type, useful for dynamically getting AL entry points. */
+typedef void          (AL_APIENTRY *LPALENABLE)(ALenum capability);
+typedef void          (AL_APIENTRY *LPALDISABLE)(ALenum capability);
+typedef ALboolean     (AL_APIENTRY *LPALISENABLED)(ALenum capability);
+typedef const ALchar* (AL_APIENTRY *LPALGETSTRING)(ALenum param);
+typedef void          (AL_APIENTRY *LPALGETBOOLEANV)(ALenum param, ALboolean *values);
+typedef void          (AL_APIENTRY *LPALGETINTEGERV)(ALenum param, ALint *values);
+typedef void          (AL_APIENTRY *LPALGETFLOATV)(ALenum param, ALfloat *values);
+typedef void          (AL_APIENTRY *LPALGETDOUBLEV)(ALenum param, ALdouble *values);
+typedef ALboolean     (AL_APIENTRY *LPALGETBOOLEAN)(ALenum param);
+typedef ALint         (AL_APIENTRY *LPALGETINTEGER)(ALenum param);
+typedef ALfloat       (AL_APIENTRY *LPALGETFLOAT)(ALenum param);
+typedef ALdouble      (AL_APIENTRY *LPALGETDOUBLE)(ALenum param);
+typedef ALenum        (AL_APIENTRY *LPALGETERROR)(void);
+typedef ALboolean     (AL_APIENTRY *LPALISEXTENSIONPRESENT)(const ALchar *extname);
+typedef void*         (AL_APIENTRY *LPALGETPROCADDRESS)(const ALchar *fname);
+typedef ALenum        (AL_APIENTRY *LPALGETENUMVALUE)(const ALchar *ename);
+typedef void          (AL_APIENTRY *LPALLISTENERF)(ALenum param, ALfloat value);
+typedef void          (AL_APIENTRY *LPALLISTENER3F)(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
+typedef void          (AL_APIENTRY *LPALLISTENERFV)(ALenum param, const ALfloat *values);
+typedef void          (AL_APIENTRY *LPALLISTENERI)(ALenum param, ALint value);
+typedef void          (AL_APIENTRY *LPALLISTENER3I)(ALenum param, ALint value1, ALint value2, ALint value3);
+typedef void          (AL_APIENTRY *LPALLISTENERIV)(ALenum param, const ALint *values);
+typedef void          (AL_APIENTRY *LPALGETLISTENERF)(ALenum param, ALfloat *value);
+typedef void          (AL_APIENTRY *LPALGETLISTENER3F)(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
+typedef void          (AL_APIENTRY *LPALGETLISTENERFV)(ALenum param, ALfloat *values);
+typedef void          (AL_APIENTRY *LPALGETLISTENERI)(ALenum param, ALint *value);
+typedef void          (AL_APIENTRY *LPALGETLISTENER3I)(ALenum param, ALint *value1, ALint *value2, ALint *value3);
+typedef void          (AL_APIENTRY *LPALGETLISTENERIV)(ALenum param, ALint *values);
+typedef void          (AL_APIENTRY *LPALGENSOURCES)(ALsizei n, ALuint *sources);
+typedef void          (AL_APIENTRY *LPALDELETESOURCES)(ALsizei n, const ALuint *sources);
+typedef ALboolean     (AL_APIENTRY *LPALISSOURCE)(ALuint source);
+typedef void          (AL_APIENTRY *LPALSOURCEF)(ALuint source, ALenum param, ALfloat value);
+typedef void          (AL_APIENTRY *LPALSOURCE3F)(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
+typedef void          (AL_APIENTRY *LPALSOURCEFV)(ALuint source, ALenum param, const ALfloat *values);
+typedef void          (AL_APIENTRY *LPALSOURCEI)(ALuint source, ALenum param, ALint value);
+typedef void          (AL_APIENTRY *LPALSOURCE3I)(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3);
+typedef void          (AL_APIENTRY *LPALSOURCEIV)(ALuint source, ALenum param, const ALint *values);
+typedef void          (AL_APIENTRY *LPALGETSOURCEF)(ALuint source, ALenum param, ALfloat *value);
+typedef void          (AL_APIENTRY *LPALGETSOURCE3F)(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
+typedef void          (AL_APIENTRY *LPALGETSOURCEFV)(ALuint source, ALenum param, ALfloat *values);
+typedef void          (AL_APIENTRY *LPALGETSOURCEI)(ALuint source, ALenum param, ALint *value);
+typedef void          (AL_APIENTRY *LPALGETSOURCE3I)(ALuint source, ALenum param, ALint *value1, ALint *value2, ALint *value3);
+typedef void          (AL_APIENTRY *LPALGETSOURCEIV)(ALuint source, ALenum param, ALint *values);
+typedef void          (AL_APIENTRY *LPALSOURCEPLAYV)(ALsizei n, const ALuint *sources);
+typedef void          (AL_APIENTRY *LPALSOURCESTOPV)(ALsizei n, const ALuint *sources);
+typedef void          (AL_APIENTRY *LPALSOURCEREWINDV)(ALsizei n, const ALuint *sources);
+typedef void          (AL_APIENTRY *LPALSOURCEPAUSEV)(ALsizei n, const ALuint *sources);
+typedef void          (AL_APIENTRY *LPALSOURCEPLAY)(ALuint source);
+typedef void          (AL_APIENTRY *LPALSOURCESTOP)(ALuint source);
+typedef void          (AL_APIENTRY *LPALSOURCEREWIND)(ALuint source);
+typedef void          (AL_APIENTRY *LPALSOURCEPAUSE)(ALuint source);
+typedef void          (AL_APIENTRY *LPALSOURCEQUEUEBUFFERS)(ALuint source, ALsizei nb, const ALuint *buffers);
+typedef void          (AL_APIENTRY *LPALSOURCEUNQUEUEBUFFERS)(ALuint source, ALsizei nb, ALuint *buffers);
+typedef void          (AL_APIENTRY *LPALGENBUFFERS)(ALsizei n, ALuint *buffers);
+typedef void          (AL_APIENTRY *LPALDELETEBUFFERS)(ALsizei n, const ALuint *buffers);
+typedef ALboolean     (AL_APIENTRY *LPALISBUFFER)(ALuint buffer);
+typedef void          (AL_APIENTRY *LPALBUFFERDATA)(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei freq);
+typedef void          (AL_APIENTRY *LPALBUFFERF)(ALuint buffer, ALenum param, ALfloat value);
+typedef void          (AL_APIENTRY *LPALBUFFER3F)(ALuint buffer, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3);
+typedef void          (AL_APIENTRY *LPALBUFFERFV)(ALuint buffer, ALenum param, const ALfloat *values);
+typedef void          (AL_APIENTRY *LPALBUFFERI)(ALuint buffer, ALenum param, ALint value);
+typedef void          (AL_APIENTRY *LPALBUFFER3I)(ALuint buffer, ALenum param, ALint value1, ALint value2, ALint value3);
+typedef void          (AL_APIENTRY *LPALBUFFERIV)(ALuint buffer, ALenum param, const ALint *values);
+typedef void          (AL_APIENTRY *LPALGETBUFFERF)(ALuint buffer, ALenum param, ALfloat *value);
+typedef void          (AL_APIENTRY *LPALGETBUFFER3F)(ALuint buffer, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3);
+typedef void          (AL_APIENTRY *LPALGETBUFFERFV)(ALuint buffer, ALenum param, ALfloat *values);
+typedef void          (AL_APIENTRY *LPALGETBUFFERI)(ALuint buffer, ALenum param, ALint *value);
+typedef void          (AL_APIENTRY *LPALGETBUFFER3I)(ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3);
+typedef void          (AL_APIENTRY *LPALGETBUFFERIV)(ALuint buffer, ALenum param, ALint *values);
+typedef void          (AL_APIENTRY *LPALDOPPLERFACTOR)(ALfloat value);
+typedef void          (AL_APIENTRY *LPALDOPPLERVELOCITY)(ALfloat value);
+typedef void          (AL_APIENTRY *LPALSPEEDOFSOUND)(ALfloat value);
+typedef void          (AL_APIENTRY *LPALDISTANCEMODEL)(ALenum distanceModel);
+
+#if defined(__cplusplus)
+}  /* extern "C" */
+#endif
+
+#endif /* AL_AL_H */

OpenAL/include/alc.h

@@ -0,0 +1,237 @@
+#ifndef AL_ALC_H
+#define AL_ALC_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#ifndef ALC_API
+ #if defined(AL_LIBTYPE_STATIC)
+  #define ALC_API
+ #elif defined(_WIN32)
+  #define ALC_API __declspec(dllimport)
+ #else
+  #define ALC_API extern
+ #endif
+#endif
+
+#if defined(_WIN32)
+ #define ALC_APIENTRY __cdecl
+#else
+ #define ALC_APIENTRY
+#endif
+
+
+/** Deprecated macro. */
+#define ALCAPI                                   ALC_API
+#define ALCAPIENTRY                              ALC_APIENTRY
+#define ALC_INVALID                              0
+
+/** Supported ALC version? */
+#define ALC_VERSION_0_1                          1
+
+/** Opaque device handle */
+typedef struct ALCdevice_struct ALCdevice;
+/** Opaque context handle */
+typedef struct ALCcontext_struct ALCcontext;
+
+/** 8-bit boolean */
+typedef char ALCboolean;
+
+/** character */
+typedef char ALCchar;
+
+/** signed 8-bit 2's complement integer */
+typedef signed char ALCbyte;
+
+/** unsigned 8-bit integer */
+typedef unsigned char ALCubyte;
+
+/** signed 16-bit 2's complement integer */
+typedef short ALCshort;
+
+/** unsigned 16-bit integer */
+typedef unsigned short ALCushort;
+
+/** signed 32-bit 2's complement integer */
+typedef int ALCint;
+
+/** unsigned 32-bit integer */
+typedef unsigned int ALCuint;
+
+/** non-negative 32-bit binary integer size */
+typedef int ALCsizei;
+
+/** enumerated 32-bit value */
+typedef int ALCenum;
+
+/** 32-bit IEEE754 floating-point */
+typedef float ALCfloat;
+
+/** 64-bit IEEE754 floating-point */
+typedef double ALCdouble;
+
+/** void type (for opaque pointers only) */
+typedef void ALCvoid;
+
+
+/* Enumerant values begin at column 50. No tabs. */
+
+/** Boolean False. */
+#define ALC_FALSE                                0
+
+/** Boolean True. */
+#define ALC_TRUE                                 1
+
+/** Context attribute: <int> Hz. */
+#define ALC_FREQUENCY                            0x1007
+
+/** Context attribute: <int> Hz. */
+#define ALC_REFRESH                              0x1008
+
+/** Context attribute: AL_TRUE or AL_FALSE. */
+#define ALC_SYNC                                 0x1009
+
+/** Context attribute: <int> requested Mono (3D) Sources. */
+#define ALC_MONO_SOURCES                         0x1010
+
+/** Context attribute: <int> requested Stereo Sources. */
+#define ALC_STEREO_SOURCES                       0x1011
+
+/** No error. */
+#define ALC_NO_ERROR                             0
+
+/** Invalid device handle. */
+#define ALC_INVALID_DEVICE                       0xA001
+
+/** Invalid context handle. */
+#define ALC_INVALID_CONTEXT                      0xA002
+
+/** Invalid enum parameter passed to an ALC call. */
+#define ALC_INVALID_ENUM                         0xA003
+
+/** Invalid value parameter passed to an ALC call. */
+#define ALC_INVALID_VALUE                        0xA004
+
+/** Out of memory. */
+#define ALC_OUT_OF_MEMORY                        0xA005
+
+
+/** Runtime ALC version. */
+#define ALC_MAJOR_VERSION                        0x1000
+#define ALC_MINOR_VERSION                        0x1001
+
+/** Context attribute list properties. */
+#define ALC_ATTRIBUTES_SIZE                      0x1002
+#define ALC_ALL_ATTRIBUTES                       0x1003
+
+/** String for the default device specifier. */
+#define ALC_DEFAULT_DEVICE_SPECIFIER             0x1004
+/**
+ * String for the given device's specifier.
+ *
+ * If device handle is NULL, it is instead a null-char separated list of
+ * strings of known device specifiers (list ends with an empty string).
+ */
+#define ALC_DEVICE_SPECIFIER                     0x1005
+/** String for space-separated list of ALC extensions. */
+#define ALC_EXTENSIONS                           0x1006
+
+
+/** Capture extension */
+#define ALC_EXT_CAPTURE 1
+/**
+ * String for the given capture device's specifier.
+ *
+ * If device handle is NULL, it is instead a null-char separated list of
+ * strings of known capture device specifiers (list ends with an empty string).
+ */
+#define ALC_CAPTURE_DEVICE_SPECIFIER             0x310
+/** String for the default capture device specifier. */
+#define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER     0x311
+/** Number of sample frames available for capture. */
+#define ALC_CAPTURE_SAMPLES                      0x312
+
+
+/** Enumerate All extension */
+#define ALC_ENUMERATE_ALL_EXT 1
+/** String for the default extended device specifier. */
+#define ALC_DEFAULT_ALL_DEVICES_SPECIFIER        0x1012
+/**
+ * String for the given extended device's specifier.
+ *
+ * If device handle is NULL, it is instead a null-char separated list of
+ * strings of known extended device specifiers (list ends with an empty string).
+ */
+#define ALC_ALL_DEVICES_SPECIFIER                0x1013
+
+
+/** Context management. */
+ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint* attrlist);
+ALC_API ALCboolean  ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context);
+ALC_API void        ALC_APIENTRY alcProcessContext(ALCcontext *context);
+ALC_API void        ALC_APIENTRY alcSuspendContext(ALCcontext *context);
+ALC_API void        ALC_APIENTRY alcDestroyContext(ALCcontext *context);
+ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(void);
+ALC_API ALCdevice*  ALC_APIENTRY alcGetContextsDevice(ALCcontext *context);
+
+/** Device management. */
+ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *devicename);
+ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *device);
+
+
+/**
+ * Error support.
+ *
+ * Obtain the most recent Device error.
+ */
+ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device);
+
+/**
+ * Extension support.
+ *
+ * Query for the presence of an extension, and obtain any appropriate
+ * function pointers and enum values.
+ */
+ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extname);
+ALC_API void*      ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcname);
+ALC_API ALCenum    ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumname);
+
+/** Query function. */
+ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *device, ALCenum param);
+ALC_API void           ALC_APIENTRY alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values);
+
+/** Capture function. */
+ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize);
+ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *device);
+ALC_API void       ALC_APIENTRY alcCaptureStart(ALCdevice *device);
+ALC_API void       ALC_APIENTRY alcCaptureStop(ALCdevice *device);
+ALC_API void       ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples);
+
+/** Pointer-to-function type, useful for dynamically getting ALC entry points. */
+typedef ALCcontext*    (ALC_APIENTRY *LPALCCREATECONTEXT)(ALCdevice *device, const ALCint *attrlist);
+typedef ALCboolean     (ALC_APIENTRY *LPALCMAKECONTEXTCURRENT)(ALCcontext *context);
+typedef void           (ALC_APIENTRY *LPALCPROCESSCONTEXT)(ALCcontext *context);
+typedef void           (ALC_APIENTRY *LPALCSUSPENDCONTEXT)(ALCcontext *context);
+typedef void           (ALC_APIENTRY *LPALCDESTROYCONTEXT)(ALCcontext *context);
+typedef ALCcontext*    (ALC_APIENTRY *LPALCGETCURRENTCONTEXT)(void);
+typedef ALCdevice*     (ALC_APIENTRY *LPALCGETCONTEXTSDEVICE)(ALCcontext *context);
+typedef ALCdevice*     (ALC_APIENTRY *LPALCOPENDEVICE)(const ALCchar *devicename);
+typedef ALCboolean     (ALC_APIENTRY *LPALCCLOSEDEVICE)(ALCdevice *device);
+typedef ALCenum        (ALC_APIENTRY *LPALCGETERROR)(ALCdevice *device);
+typedef ALCboolean     (ALC_APIENTRY *LPALCISEXTENSIONPRESENT)(ALCdevice *device, const ALCchar *extname);
+typedef void*          (ALC_APIENTRY *LPALCGETPROCADDRESS)(ALCdevice *device, const ALCchar *funcname);
+typedef ALCenum        (ALC_APIENTRY *LPALCGETENUMVALUE)(ALCdevice *device, const ALCchar *enumname);
+typedef const ALCchar* (ALC_APIENTRY *LPALCGETSTRING)(ALCdevice *device, ALCenum param);
+typedef void           (ALC_APIENTRY *LPALCGETINTEGERV)(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values);
+typedef ALCdevice*     (ALC_APIENTRY *LPALCCAPTUREOPENDEVICE)(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize);
+typedef ALCboolean     (ALC_APIENTRY *LPALCCAPTURECLOSEDEVICE)(ALCdevice *device);
+typedef void           (ALC_APIENTRY *LPALCCAPTURESTART)(ALCdevice *device);
+typedef void           (ALC_APIENTRY *LPALCCAPTURESTOP)(ALCdevice *device);
+typedef void           (ALC_APIENTRY *LPALCCAPTURESAMPLES)(ALCdevice *device, ALCvoid *buffer, ALCsizei samples);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* AL_ALC_H */

OpenAL/include/alext.h

@@ -0,0 +1,400 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 2008 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *  Boston, MA  02111-1307, USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#ifndef AL_ALEXT_H
+#define AL_ALEXT_H
+
+#include <stddef.h>
+/* Define int64_t and uint64_t types */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+#include <inttypes.h>
+#elif defined(_WIN32) && defined(__GNUC__)
+#include <stdint.h>
+#elif defined(_WIN32)
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+#else
+/* Fallback if nothing above works */
+#include <inttypes.h>
+#endif
+
+#include "alc.h"
+#include "al.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef AL_LOKI_IMA_ADPCM_format
+#define AL_LOKI_IMA_ADPCM_format 1
+#define AL_FORMAT_IMA_ADPCM_MONO16_EXT           0x10000
+#define AL_FORMAT_IMA_ADPCM_STEREO16_EXT         0x10001
+#endif
+
+#ifndef AL_LOKI_WAVE_format
+#define AL_LOKI_WAVE_format 1
+#define AL_FORMAT_WAVE_EXT                       0x10002
+#endif
+
+#ifndef AL_EXT_vorbis
+#define AL_EXT_vorbis 1
+#define AL_FORMAT_VORBIS_EXT                     0x10003
+#endif
+
+#ifndef AL_LOKI_quadriphonic
+#define AL_LOKI_quadriphonic 1
+#define AL_FORMAT_QUAD8_LOKI                     0x10004
+#define AL_FORMAT_QUAD16_LOKI                    0x10005
+#endif
+
+#ifndef AL_EXT_float32
+#define AL_EXT_float32 1
+#define AL_FORMAT_MONO_FLOAT32                   0x10010
+#define AL_FORMAT_STEREO_FLOAT32                 0x10011
+#endif
+
+#ifndef AL_EXT_double
+#define AL_EXT_double 1
+#define AL_FORMAT_MONO_DOUBLE_EXT                0x10012
+#define AL_FORMAT_STEREO_DOUBLE_EXT              0x10013
+#endif
+
+#ifndef AL_EXT_MULAW
+#define AL_EXT_MULAW 1
+#define AL_FORMAT_MONO_MULAW_EXT                 0x10014
+#define AL_FORMAT_STEREO_MULAW_EXT               0x10015
+#endif
+
+#ifndef AL_EXT_ALAW
+#define AL_EXT_ALAW 1
+#define AL_FORMAT_MONO_ALAW_EXT                  0x10016
+#define AL_FORMAT_STEREO_ALAW_EXT                0x10017
+#endif
+
+#ifndef ALC_LOKI_audio_channel
+#define ALC_LOKI_audio_channel 1
+#define ALC_CHAN_MAIN_LOKI                       0x500001
+#define ALC_CHAN_PCM_LOKI                        0x500002
+#define ALC_CHAN_CD_LOKI                         0x500003
+#endif
+
+#ifndef AL_EXT_MCFORMATS
+#define AL_EXT_MCFORMATS 1
+#define AL_FORMAT_QUAD8                          0x1204
+#define AL_FORMAT_QUAD16                         0x1205
+#define AL_FORMAT_QUAD32                         0x1206
+#define AL_FORMAT_REAR8                          0x1207
+#define AL_FORMAT_REAR16                         0x1208
+#define AL_FORMAT_REAR32                         0x1209
+#define AL_FORMAT_51CHN8                         0x120A
+#define AL_FORMAT_51CHN16                        0x120B
+#define AL_FORMAT_51CHN32                        0x120C
+#define AL_FORMAT_61CHN8                         0x120D
+#define AL_FORMAT_61CHN16                        0x120E
+#define AL_FORMAT_61CHN32                        0x120F
+#define AL_FORMAT_71CHN8                         0x1210
+#define AL_FORMAT_71CHN16                        0x1211
+#define AL_FORMAT_71CHN32                        0x1212
+#endif
+
+#ifndef AL_EXT_MULAW_MCFORMATS
+#define AL_EXT_MULAW_MCFORMATS 1
+#define AL_FORMAT_MONO_MULAW                     0x10014
+#define AL_FORMAT_STEREO_MULAW                   0x10015
+#define AL_FORMAT_QUAD_MULAW                     0x10021
+#define AL_FORMAT_REAR_MULAW                     0x10022
+#define AL_FORMAT_51CHN_MULAW                    0x10023
+#define AL_FORMAT_61CHN_MULAW                    0x10024
+#define AL_FORMAT_71CHN_MULAW                    0x10025
+#endif
+
+#ifndef AL_EXT_IMA4
+#define AL_EXT_IMA4 1
+#define AL_FORMAT_MONO_IMA4                      0x1300
+#define AL_FORMAT_STEREO_IMA4                    0x1301
+#endif
+
+#ifndef AL_EXT_STATIC_BUFFER
+#define AL_EXT_STATIC_BUFFER 1
+typedef ALvoid (AL_APIENTRY*PFNALBUFFERDATASTATICPROC)(const ALint,ALenum,ALvoid*,ALsizei,ALsizei);
+#ifdef AL_ALEXT_PROTOTYPES
+AL_API ALvoid AL_APIENTRY alBufferDataStatic(const ALint buffer, ALenum format, ALvoid *data, ALsizei len, ALsizei freq);
+#endif
+#endif
+
+#ifndef ALC_EXT_EFX
+#define ALC_EXT_EFX 1
+#include "efx.h"
+#endif
+
+#ifndef ALC_EXT_disconnect
+#define ALC_EXT_disconnect 1
+#define ALC_CONNECTED                            0x313
+#endif
+
+#ifndef ALC_EXT_thread_local_context
+#define ALC_EXT_thread_local_context 1
+typedef ALCboolean  (ALC_APIENTRY*PFNALCSETTHREADCONTEXTPROC)(ALCcontext *context);
+typedef ALCcontext* (ALC_APIENTRY*PFNALCGETTHREADCONTEXTPROC)(void);
+#ifdef AL_ALEXT_PROTOTYPES
+ALC_API ALCboolean  ALC_APIENTRY alcSetThreadContext(ALCcontext *context);
+ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void);
+#endif
+#endif
+
+#ifndef AL_EXT_source_distance_model
+#define AL_EXT_source_distance_model 1
+#define AL_SOURCE_DISTANCE_MODEL                 0x200
+#endif
+
+#ifndef AL_SOFT_buffer_sub_data
+#define AL_SOFT_buffer_sub_data 1
+#define AL_BYTE_RW_OFFSETS_SOFT                  0x1031
+#define AL_SAMPLE_RW_OFFSETS_SOFT                0x1032
+typedef ALvoid (AL_APIENTRY*PFNALBUFFERSUBDATASOFTPROC)(ALuint,ALenum,const ALvoid*,ALsizei,ALsizei);
+#ifdef AL_ALEXT_PROTOTYPES
+AL_API ALvoid AL_APIENTRY alBufferSubDataSOFT(ALuint buffer,ALenum format,const ALvoid *data,ALsizei offset,ALsizei length);
+#endif
+#endif
+
+#ifndef AL_SOFT_loop_points
+#define AL_SOFT_loop_points 1
+#define AL_LOOP_POINTS_SOFT                      0x2015
+#endif
+
+#ifndef AL_EXT_FOLDBACK
+#define AL_EXT_FOLDBACK 1
+#define AL_EXT_FOLDBACK_NAME                     "AL_EXT_FOLDBACK"
+#define AL_FOLDBACK_EVENT_BLOCK                  0x4112
+#define AL_FOLDBACK_EVENT_START                  0x4111
+#define AL_FOLDBACK_EVENT_STOP                   0x4113
+#define AL_FOLDBACK_MODE_MONO                    0x4101
+#define AL_FOLDBACK_MODE_STEREO                  0x4102
+typedef void (AL_APIENTRY*LPALFOLDBACKCALLBACK)(ALenum,ALsizei);
+typedef void (AL_APIENTRY*LPALREQUESTFOLDBACKSTART)(ALenum,ALsizei,ALsizei,ALfloat*,LPALFOLDBACKCALLBACK);
+typedef void (AL_APIENTRY*LPALREQUESTFOLDBACKSTOP)(void);
+#ifdef AL_ALEXT_PROTOTYPES
+AL_API void AL_APIENTRY alRequestFoldbackStart(ALenum mode,ALsizei count,ALsizei length,ALfloat *mem,LPALFOLDBACKCALLBACK callback);
+AL_API void AL_APIENTRY alRequestFoldbackStop(void);
+#endif
+#endif
+
+#ifndef ALC_EXT_DEDICATED
+#define ALC_EXT_DEDICATED 1
+#define AL_DEDICATED_GAIN                        0x0001
+#define AL_EFFECT_DEDICATED_DIALOGUE             0x9001
+#define AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT 0x9000
+#endif
+
+#ifndef AL_SOFT_buffer_samples
+#define AL_SOFT_buffer_samples 1
+/* Channel configurations */
+#define AL_MONO_SOFT                             0x1500
+#define AL_STEREO_SOFT                           0x1501
+#define AL_REAR_SOFT                             0x1502
+#define AL_QUAD_SOFT                             0x1503
+#define AL_5POINT1_SOFT                          0x1504
+#define AL_6POINT1_SOFT                          0x1505
+#define AL_7POINT1_SOFT                          0x1506
+
+/* Sample types */
+#define AL_BYTE_SOFT                             0x1400
+#define AL_UNSIGNED_BYTE_SOFT                    0x1401
+#define AL_SHORT_SOFT                            0x1402
+#define AL_UNSIGNED_SHORT_SOFT                   0x1403
+#define AL_INT_SOFT                              0x1404
+#define AL_UNSIGNED_INT_SOFT                     0x1405
+#define AL_FLOAT_SOFT                            0x1406
+#define AL_DOUBLE_SOFT                           0x1407
+#define AL_BYTE3_SOFT                            0x1408
+#define AL_UNSIGNED_BYTE3_SOFT                   0x1409
+
+/* Storage formats */
+#define AL_MONO8_SOFT                            0x1100
+#define AL_MONO16_SOFT                           0x1101
+#define AL_MONO32F_SOFT                          0x10010
+#define AL_STEREO8_SOFT                          0x1102
+#define AL_STEREO16_SOFT                         0x1103
+#define AL_STEREO32F_SOFT                        0x10011
+#define AL_QUAD8_SOFT                            0x1204
+#define AL_QUAD16_SOFT                           0x1205
+#define AL_QUAD32F_SOFT                          0x1206
+#define AL_REAR8_SOFT                            0x1207
+#define AL_REAR16_SOFT                           0x1208
+#define AL_REAR32F_SOFT                          0x1209
+#define AL_5POINT1_8_SOFT                        0x120A
+#define AL_5POINT1_16_SOFT                       0x120B
+#define AL_5POINT1_32F_SOFT                      0x120C
+#define AL_6POINT1_8_SOFT                        0x120D
+#define AL_6POINT1_16_SOFT                       0x120E
+#define AL_6POINT1_32F_SOFT                      0x120F
+#define AL_7POINT1_8_SOFT                        0x1210
+#define AL_7POINT1_16_SOFT                       0x1211
+#define AL_7POINT1_32F_SOFT                      0x1212
+
+/* Buffer attributes */
+#define AL_INTERNAL_FORMAT_SOFT                  0x2008
+#define AL_BYTE_LENGTH_SOFT                      0x2009
+#define AL_SAMPLE_LENGTH_SOFT                    0x200A
+#define AL_SEC_LENGTH_SOFT                       0x200B
+
+typedef void (AL_APIENTRY*LPALBUFFERSAMPLESSOFT)(ALuint,ALuint,ALenum,ALsizei,ALenum,ALenum,const ALvoid*);
+typedef void (AL_APIENTRY*LPALBUFFERSUBSAMPLESSOFT)(ALuint,ALsizei,ALsizei,ALenum,ALenum,const ALvoid*);
+typedef void (AL_APIENTRY*LPALGETBUFFERSAMPLESSOFT)(ALuint,ALsizei,ALsizei,ALenum,ALenum,ALvoid*);
+typedef ALboolean (AL_APIENTRY*LPALISBUFFERFORMATSUPPORTEDSOFT)(ALenum);
+#ifdef AL_ALEXT_PROTOTYPES
+AL_API void AL_APIENTRY alBufferSamplesSOFT(ALuint buffer, ALuint samplerate, ALenum internalformat, ALsizei samples, ALenum channels, ALenum type, const ALvoid *data);
+AL_API void AL_APIENTRY alBufferSubSamplesSOFT(ALuint buffer, ALsizei offset, ALsizei samples, ALenum channels, ALenum type, const ALvoid *data);
+AL_API void AL_APIENTRY alGetBufferSamplesSOFT(ALuint buffer, ALsizei offset, ALsizei samples, ALenum channels, ALenum type, ALvoid *data);
+AL_API ALboolean AL_APIENTRY alIsBufferFormatSupportedSOFT(ALenum format);
+#endif
+#endif
+
+#ifndef AL_SOFT_direct_channels
+#define AL_SOFT_direct_channels 1
+#define AL_DIRECT_CHANNELS_SOFT                  0x1033
+#endif
+
+#ifndef ALC_SOFT_loopback
+#define ALC_SOFT_loopback 1
+#define ALC_FORMAT_CHANNELS_SOFT                 0x1990
+#define ALC_FORMAT_TYPE_SOFT                     0x1991
+
+/* Sample types */
+#define ALC_BYTE_SOFT                            0x1400
+#define ALC_UNSIGNED_BYTE_SOFT                   0x1401
+#define ALC_SHORT_SOFT                           0x1402
+#define ALC_UNSIGNED_SHORT_SOFT                  0x1403
+#define ALC_INT_SOFT                             0x1404
+#define ALC_UNSIGNED_INT_SOFT                    0x1405
+#define ALC_FLOAT_SOFT                           0x1406
+
+/* Channel configurations */
+#define ALC_MONO_SOFT                            0x1500
+#define ALC_STEREO_SOFT                          0x1501
+#define ALC_QUAD_SOFT                            0x1503
+#define ALC_5POINT1_SOFT                         0x1504
+#define ALC_6POINT1_SOFT                         0x1505
+#define ALC_7POINT1_SOFT                         0x1506
+
+typedef ALCdevice* (ALC_APIENTRY*LPALCLOOPBACKOPENDEVICESOFT)(const ALCchar*);
+typedef ALCboolean (ALC_APIENTRY*LPALCISRENDERFORMATSUPPORTEDSOFT)(ALCdevice*,ALCsizei,ALCenum,ALCenum);
+typedef void (ALC_APIENTRY*LPALCRENDERSAMPLESSOFT)(ALCdevice*,ALCvoid*,ALCsizei);
+#ifdef AL_ALEXT_PROTOTYPES
+ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(const ALCchar *deviceName);
+ALC_API ALCboolean ALC_APIENTRY alcIsRenderFormatSupportedSOFT(ALCdevice *device, ALCsizei freq, ALCenum channels, ALCenum type);
+ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffer, ALCsizei samples);
+#endif
+#endif
+
+#ifndef AL_EXT_STEREO_ANGLES
+#define AL_EXT_STEREO_ANGLES 1
+#define AL_STEREO_ANGLES                         0x1030
+#endif
+
+#ifndef AL_EXT_SOURCE_RADIUS
+#define AL_EXT_SOURCE_RADIUS 1
+#define AL_SOURCE_RADIUS                         0x1031
+#endif
+
+#ifndef AL_SOFT_source_latency
+#define AL_SOFT_source_latency 1
+#define AL_SAMPLE_OFFSET_LATENCY_SOFT            0x1200
+#define AL_SEC_OFFSET_LATENCY_SOFT               0x1201
+typedef int64_t ALint64SOFT;
+typedef uint64_t ALuint64SOFT;
+typedef void (AL_APIENTRY*LPALSOURCEDSOFT)(ALuint,ALenum,ALdouble);
+typedef void (AL_APIENTRY*LPALSOURCE3DSOFT)(ALuint,ALenum,ALdouble,ALdouble,ALdouble);
+typedef void (AL_APIENTRY*LPALSOURCEDVSOFT)(ALuint,ALenum,const ALdouble*);
+typedef void (AL_APIENTRY*LPALGETSOURCEDSOFT)(ALuint,ALenum,ALdouble*);
+typedef void (AL_APIENTRY*LPALGETSOURCE3DSOFT)(ALuint,ALenum,ALdouble*,ALdouble*,ALdouble*);
+typedef void (AL_APIENTRY*LPALGETSOURCEDVSOFT)(ALuint,ALenum,ALdouble*);
+typedef void (AL_APIENTRY*LPALSOURCEI64SOFT)(ALuint,ALenum,ALint64SOFT);
+typedef void (AL_APIENTRY*LPALSOURCE3I64SOFT)(ALuint,ALenum,ALint64SOFT,ALint64SOFT,ALint64SOFT);
+typedef void (AL_APIENTRY*LPALSOURCEI64VSOFT)(ALuint,ALenum,const ALint64SOFT*);
+typedef void (AL_APIENTRY*LPALGETSOURCEI64SOFT)(ALuint,ALenum,ALint64SOFT*);
+typedef void (AL_APIENTRY*LPALGETSOURCE3I64SOFT)(ALuint,ALenum,ALint64SOFT*,ALint64SOFT*,ALint64SOFT*);
+typedef void (AL_APIENTRY*LPALGETSOURCEI64VSOFT)(ALuint,ALenum,ALint64SOFT*);
+#ifdef AL_ALEXT_PROTOTYPES
+AL_API void AL_APIENTRY alSourcedSOFT(ALuint source, ALenum param, ALdouble value);
+AL_API void AL_APIENTRY alSource3dSOFT(ALuint source, ALenum param, ALdouble value1, ALdouble value2, ALdouble value3);
+AL_API void AL_APIENTRY alSourcedvSOFT(ALuint source, ALenum param, const ALdouble *values);
+AL_API void AL_APIENTRY alGetSourcedSOFT(ALuint source, ALenum param, ALdouble *value);
+AL_API void AL_APIENTRY alGetSource3dSOFT(ALuint source, ALenum param, ALdouble *value1, ALdouble *value2, ALdouble *value3);
+AL_API void AL_APIENTRY alGetSourcedvSOFT(ALuint source, ALenum param, ALdouble *values);
+AL_API void AL_APIENTRY alSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT value);
+AL_API void AL_APIENTRY alSource3i64SOFT(ALuint source, ALenum param, ALint64SOFT value1, ALint64SOFT value2, ALint64SOFT value3);
+AL_API void AL_APIENTRY alSourcei64vSOFT(ALuint source, ALenum param, const ALint64SOFT *values);
+AL_API void AL_APIENTRY alGetSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT *value);
+AL_API void AL_APIENTRY alGetSource3i64SOFT(ALuint source, ALenum param, ALint64SOFT *value1, ALint64SOFT *value2, ALint64SOFT *value3);
+AL_API void AL_APIENTRY alGetSourcei64vSOFT(ALuint source, ALenum param, ALint64SOFT *values);
+#endif
+#endif
+
+#ifndef ALC_EXT_DEFAULT_FILTER_ORDER
+#define ALC_EXT_DEFAULT_FILTER_ORDER 1
+#define ALC_DEFAULT_FILTER_ORDER                 0x1100
+#endif
+
+#ifndef AL_SOFT_deferred_updates
+#define AL_SOFT_deferred_updates 1
+#define AL_DEFERRED_UPDATES_SOFT                 0xC002
+typedef ALvoid (AL_APIENTRY*LPALDEFERUPDATESSOFT)(void);
+typedef ALvoid (AL_APIENTRY*LPALPROCESSUPDATESSOFT)(void);
+#ifdef AL_ALEXT_PROTOTYPES
+AL_API ALvoid AL_APIENTRY alDeferUpdatesSOFT(void);
+AL_API ALvoid AL_APIENTRY alProcessUpdatesSOFT(void);
+#endif
+#endif
+
+#ifndef AL_SOFT_block_alignment
+#define AL_SOFT_block_alignment 1
+#define AL_UNPACK_BLOCK_ALIGNMENT_SOFT           0x200C
+#define AL_PACK_BLOCK_ALIGNMENT_SOFT             0x200D
+#endif
+
+#ifndef AL_SOFT_MSADPCM
+#define AL_SOFT_MSADPCM 1
+#define AL_FORMAT_MONO_MSADPCM_SOFT              0x1302
+#define AL_FORMAT_STEREO_MSADPCM_SOFT            0x1303
+#endif
+
+#ifndef AL_SOFT_source_length
+#define AL_SOFT_source_length 1
+/*#define AL_BYTE_LENGTH_SOFT                      0x2009*/
+/*#define AL_SAMPLE_LENGTH_SOFT                    0x200A*/
+/*#define AL_SEC_LENGTH_SOFT                       0x200B*/
+#endif
+
+#ifndef ALC_SOFT_pause_device
+#define ALC_SOFT_pause_device 1
+typedef void (ALC_APIENTRY*LPALCDEVICEPAUSESOFT)(ALCdevice *device);
+typedef void (ALC_APIENTRY*LPALCDEVICERESUMESOFT)(ALCdevice *device);
+#ifdef AL_ALEXT_PROTOTYPES
+ALC_API void ALC_APIENTRY alcDevicePauseSOFT(ALCdevice *device);
+ALC_API void ALC_APIENTRY alcDeviceResumeSOFT(ALCdevice *device);
+#endif
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

OpenAL/include/efx-creative.h

@@ -0,0 +1,3 @@
+/* The tokens that would be defined here are already defined in efx.h. This
+ * empty file is here to provide compatibility with Windows-based projects
+ * that would include it. */

OpenAL/include/efx-presets.h

@@ -0,0 +1,402 @@
+/* Reverb presets for EFX */
+
+#ifndef EFX_PRESETS_H
+#define EFX_PRESETS_H
+
+#ifndef EFXEAXREVERBPROPERTIES_DEFINED
+#define EFXEAXREVERBPROPERTIES_DEFINED
+typedef struct {
+    float flDensity;
+    float flDiffusion;
+    float flGain;
+    float flGainHF;
+    float flGainLF;
+    float flDecayTime;
+    float flDecayHFRatio;
+    float flDecayLFRatio;
+    float flReflectionsGain;
+    float flReflectionsDelay;
+    float flReflectionsPan[3];
+    float flLateReverbGain;
+    float flLateReverbDelay;
+    float flLateReverbPan[3];
+    float flEchoTime;
+    float flEchoDepth;
+    float flModulationTime;
+    float flModulationDepth;
+    float flAirAbsorptionGainHF;
+    float flHFReference;
+    float flLFReference;
+    float flRoomRolloffFactor;
+    int   iDecayHFLimit;
+} EFXEAXREVERBPROPERTIES, *LPEFXEAXREVERBPROPERTIES;
+#endif
+
+/* Default Presets */
+
+#define EFX_REVERB_PRESET_GENERIC \
+    { 1.0000f, 1.0000f, 0.3162f, 0.8913f, 1.0000f, 1.4900f, 0.8300f, 1.0000f, 0.0500f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_PADDEDCELL \
+    { 0.1715f, 1.0000f, 0.3162f, 0.0010f, 1.0000f, 0.1700f, 0.1000f, 1.0000f, 0.2500f, 0.0010f, { 0.0000f, 0.0000f, 0.0000f }, 1.2691f, 0.0020f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_ROOM \
+    { 0.4287f, 1.0000f, 0.3162f, 0.5929f, 1.0000f, 0.4000f, 0.8300f, 1.0000f, 0.1503f, 0.0020f, { 0.0000f, 0.0000f, 0.0000f }, 1.0629f, 0.0030f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_BATHROOM \
+    { 0.1715f, 1.0000f, 0.3162f, 0.2512f, 1.0000f, 1.4900f, 0.5400f, 1.0000f, 0.6531f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 3.2734f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_LIVINGROOM \
+    { 0.9766f, 1.0000f, 0.3162f, 0.0010f, 1.0000f, 0.5000f, 0.1000f, 1.0000f, 0.2051f, 0.0030f, { 0.0000f, 0.0000f, 0.0000f }, 0.2805f, 0.0040f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_STONEROOM \
+    { 1.0000f, 1.0000f, 0.3162f, 0.7079f, 1.0000f, 2.3100f, 0.6400f, 1.0000f, 0.4411f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.1003f, 0.0170f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_AUDITORIUM \
+    { 1.0000f, 1.0000f, 0.3162f, 0.5781f, 1.0000f, 4.3200f, 0.5900f, 1.0000f, 0.4032f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.7170f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_CONCERTHALL \
+    { 1.0000f, 1.0000f, 0.3162f, 0.5623f, 1.0000f, 3.9200f, 0.7000f, 1.0000f, 0.2427f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.9977f, 0.0290f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_CAVE \
+    { 1.0000f, 1.0000f, 0.3162f, 1.0000f, 1.0000f, 2.9100f, 1.3000f, 1.0000f, 0.5000f, 0.0150f, { 0.0000f, 0.0000f, 0.0000f }, 0.7063f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_ARENA \
+    { 1.0000f, 1.0000f, 0.3162f, 0.4477f, 1.0000f, 7.2400f, 0.3300f, 1.0000f, 0.2612f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 1.0186f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_HANGAR \
+    { 1.0000f, 1.0000f, 0.3162f, 0.3162f, 1.0000f, 10.0500f, 0.2300f, 1.0000f, 0.5000f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 1.2560f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_CARPETEDHALLWAY \
+    { 0.4287f, 1.0000f, 0.3162f, 0.0100f, 1.0000f, 0.3000f, 0.1000f, 1.0000f, 0.1215f, 0.0020f, { 0.0000f, 0.0000f, 0.0000f }, 0.1531f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_HALLWAY \
+    { 0.3645f, 1.0000f, 0.3162f, 0.7079f, 1.0000f, 1.4900f, 0.5900f, 1.0000f, 0.2458f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.6615f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_STONECORRIDOR \
+    { 1.0000f, 1.0000f, 0.3162f, 0.7612f, 1.0000f, 2.7000f, 0.7900f, 1.0000f, 0.2472f, 0.0130f, { 0.0000f, 0.0000f, 0.0000f }, 1.5758f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_ALLEY \
+    { 1.0000f, 0.3000f, 0.3162f, 0.7328f, 1.0000f, 1.4900f, 0.8600f, 1.0000f, 0.2500f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 0.9954f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.1250f, 0.9500f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_FOREST \
+    { 1.0000f, 0.3000f, 0.3162f, 0.0224f, 1.0000f, 1.4900f, 0.5400f, 1.0000f, 0.0525f, 0.1620f, { 0.0000f, 0.0000f, 0.0000f }, 0.7682f, 0.0880f, { 0.0000f, 0.0000f, 0.0000f }, 0.1250f, 1.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_CITY \
+    { 1.0000f, 0.5000f, 0.3162f, 0.3981f, 1.0000f, 1.4900f, 0.6700f, 1.0000f, 0.0730f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 0.1427f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_MOUNTAINS \
+    { 1.0000f, 0.2700f, 0.3162f, 0.0562f, 1.0000f, 1.4900f, 0.2100f, 1.0000f, 0.0407f, 0.3000f, { 0.0000f, 0.0000f, 0.0000f }, 0.1919f, 0.1000f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_QUARRY \
+    { 1.0000f, 1.0000f, 0.3162f, 0.3162f, 1.0000f, 1.4900f, 0.8300f, 1.0000f, 0.0000f, 0.0610f, { 0.0000f, 0.0000f, 0.0000f }, 1.7783f, 0.0250f, { 0.0000f, 0.0000f, 0.0000f }, 0.1250f, 0.7000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_PLAIN \
+    { 1.0000f, 0.2100f, 0.3162f, 0.1000f, 1.0000f, 1.4900f, 0.5000f, 1.0000f, 0.0585f, 0.1790f, { 0.0000f, 0.0000f, 0.0000f }, 0.1089f, 0.1000f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_PARKINGLOT \
+    { 1.0000f, 1.0000f, 0.3162f, 1.0000f, 1.0000f, 1.6500f, 1.5000f, 1.0000f, 0.2082f, 0.0080f, { 0.0000f, 0.0000f, 0.0000f }, 0.2652f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_SEWERPIPE \
+    { 0.3071f, 0.8000f, 0.3162f, 0.3162f, 1.0000f, 2.8100f, 0.1400f, 1.0000f, 1.6387f, 0.0140f, { 0.0000f, 0.0000f, 0.0000f }, 3.2471f, 0.0210f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_UNDERWATER \
+    { 0.3645f, 1.0000f, 0.3162f, 0.0100f, 1.0000f, 1.4900f, 0.1000f, 1.0000f, 0.5963f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 7.0795f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 1.1800f, 0.3480f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_DRUGGED \
+    { 0.4287f, 0.5000f, 0.3162f, 1.0000f, 1.0000f, 8.3900f, 1.3900f, 1.0000f, 0.8760f, 0.0020f, { 0.0000f, 0.0000f, 0.0000f }, 3.1081f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 1.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_DIZZY \
+    { 0.3645f, 0.6000f, 0.3162f, 0.6310f, 1.0000f, 17.2300f, 0.5600f, 1.0000f, 0.1392f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.4937f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.8100f, 0.3100f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_PSYCHOTIC \
+    { 0.0625f, 0.5000f, 0.3162f, 0.8404f, 1.0000f, 7.5600f, 0.9100f, 1.0000f, 0.4864f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 2.4378f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 4.0000f, 1.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
+
+/* Castle Presets */
+
+#define EFX_REVERB_PRESET_CASTLE_SMALLROOM \
+    { 1.0000f, 0.8900f, 0.3162f, 0.3981f, 0.1000f, 1.2200f, 0.8300f, 0.3100f, 0.8913f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 1.9953f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.1380f, 0.0800f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_CASTLE_SHORTPASSAGE \
+    { 1.0000f, 0.8900f, 0.3162f, 0.3162f, 0.1000f, 2.3200f, 0.8300f, 0.3100f, 0.8913f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0230f, { 0.0000f, 0.0000f, 0.0000f }, 0.1380f, 0.0800f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_CASTLE_MEDIUMROOM \
+    { 1.0000f, 0.9300f, 0.3162f, 0.2818f, 0.1000f, 2.0400f, 0.8300f, 0.4600f, 0.6310f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 1.5849f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.1550f, 0.0300f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_CASTLE_LARGEROOM \
+    { 1.0000f, 0.8200f, 0.3162f, 0.2818f, 0.1259f, 2.5300f, 0.8300f, 0.5000f, 0.4467f, 0.0340f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0160f, { 0.0000f, 0.0000f, 0.0000f }, 0.1850f, 0.0700f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_CASTLE_LONGPASSAGE \
+    { 1.0000f, 0.8900f, 0.3162f, 0.3981f, 0.1000f, 3.4200f, 0.8300f, 0.3100f, 0.8913f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0230f, { 0.0000f, 0.0000f, 0.0000f }, 0.1380f, 0.0800f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_CASTLE_HALL \
+    { 1.0000f, 0.8100f, 0.3162f, 0.2818f, 0.1778f, 3.1400f, 0.7900f, 0.6200f, 0.1778f, 0.0560f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0240f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_CASTLE_CUPBOARD \
+    { 1.0000f, 0.8900f, 0.3162f, 0.2818f, 0.1000f, 0.6700f, 0.8700f, 0.3100f, 1.4125f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 3.5481f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 0.1380f, 0.0800f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_CASTLE_COURTYARD \
+    { 1.0000f, 0.4200f, 0.3162f, 0.4467f, 0.1995f, 2.1300f, 0.6100f, 0.2300f, 0.2239f, 0.1600f, { 0.0000f, 0.0000f, 0.0000f }, 0.7079f, 0.0360f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.3700f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_CASTLE_ALCOVE \
+    { 1.0000f, 0.8900f, 0.3162f, 0.5012f, 0.1000f, 1.6400f, 0.8700f, 0.3100f, 1.0000f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0340f, { 0.0000f, 0.0000f, 0.0000f }, 0.1380f, 0.0800f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 }
+
+/* Factory Presets */
+
+#define EFX_REVERB_PRESET_FACTORY_SMALLROOM \
+    { 0.3645f, 0.8200f, 0.3162f, 0.7943f, 0.5012f, 1.7200f, 0.6500f, 1.3100f, 0.7079f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.7783f, 0.0240f, { 0.0000f, 0.0000f, 0.0000f }, 0.1190f, 0.0700f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_FACTORY_SHORTPASSAGE \
+    { 0.3645f, 0.6400f, 0.2512f, 0.7943f, 0.5012f, 2.5300f, 0.6500f, 1.3100f, 1.0000f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0380f, { 0.0000f, 0.0000f, 0.0000f }, 0.1350f, 0.2300f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_FACTORY_MEDIUMROOM \
+    { 0.4287f, 0.8200f, 0.2512f, 0.7943f, 0.5012f, 2.7600f, 0.6500f, 1.3100f, 0.2818f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0230f, { 0.0000f, 0.0000f, 0.0000f }, 0.1740f, 0.0700f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_FACTORY_LARGEROOM \
+    { 0.4287f, 0.7500f, 0.2512f, 0.7079f, 0.6310f, 4.2400f, 0.5100f, 1.3100f, 0.1778f, 0.0390f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0230f, { 0.0000f, 0.0000f, 0.0000f }, 0.2310f, 0.0700f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_FACTORY_LONGPASSAGE \
+    { 0.3645f, 0.6400f, 0.2512f, 0.7943f, 0.5012f, 4.0600f, 0.6500f, 1.3100f, 1.0000f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0370f, { 0.0000f, 0.0000f, 0.0000f }, 0.1350f, 0.2300f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_FACTORY_HALL \
+    { 0.4287f, 0.7500f, 0.3162f, 0.7079f, 0.6310f, 7.4300f, 0.5100f, 1.3100f, 0.0631f, 0.0730f, { 0.0000f, 0.0000f, 0.0000f }, 0.8913f, 0.0270f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0700f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_FACTORY_CUPBOARD \
+    { 0.3071f, 0.6300f, 0.2512f, 0.7943f, 0.5012f, 0.4900f, 0.6500f, 1.3100f, 1.2589f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.9953f, 0.0320f, { 0.0000f, 0.0000f, 0.0000f }, 0.1070f, 0.0700f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_FACTORY_COURTYARD \
+    { 0.3071f, 0.5700f, 0.3162f, 0.3162f, 0.6310f, 2.3200f, 0.2900f, 0.5600f, 0.2239f, 0.1400f, { 0.0000f, 0.0000f, 0.0000f }, 0.3981f, 0.0390f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.2900f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_FACTORY_ALCOVE \
+    { 0.3645f, 0.5900f, 0.2512f, 0.7943f, 0.5012f, 3.1400f, 0.6500f, 1.3100f, 1.4125f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.0000f, 0.0380f, { 0.0000f, 0.0000f, 0.0000f }, 0.1140f, 0.1000f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 }
+
+/* Ice Palace Presets */
+
+#define EFX_REVERB_PRESET_ICEPALACE_SMALLROOM \
+    { 1.0000f, 0.8400f, 0.3162f, 0.5623f, 0.2818f, 1.5100f, 1.5300f, 0.2700f, 0.8913f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.1640f, 0.1400f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_ICEPALACE_SHORTPASSAGE \
+    { 1.0000f, 0.7500f, 0.3162f, 0.5623f, 0.2818f, 1.7900f, 1.4600f, 0.2800f, 0.5012f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0190f, { 0.0000f, 0.0000f, 0.0000f }, 0.1770f, 0.0900f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_ICEPALACE_MEDIUMROOM \
+    { 1.0000f, 0.8700f, 0.3162f, 0.5623f, 0.4467f, 2.2200f, 1.5300f, 0.3200f, 0.3981f, 0.0390f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0270f, { 0.0000f, 0.0000f, 0.0000f }, 0.1860f, 0.1200f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_ICEPALACE_LARGEROOM \
+    { 1.0000f, 0.8100f, 0.3162f, 0.5623f, 0.4467f, 3.1400f, 1.5300f, 0.3200f, 0.2512f, 0.0390f, { 0.0000f, 0.0000f, 0.0000f }, 1.0000f, 0.0270f, { 0.0000f, 0.0000f, 0.0000f }, 0.2140f, 0.1100f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_ICEPALACE_LONGPASSAGE \
+    { 1.0000f, 0.7700f, 0.3162f, 0.5623f, 0.3981f, 3.0100f, 1.4600f, 0.2800f, 0.7943f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0250f, { 0.0000f, 0.0000f, 0.0000f }, 0.1860f, 0.0400f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_ICEPALACE_HALL \
+    { 1.0000f, 0.7600f, 0.3162f, 0.4467f, 0.5623f, 5.4900f, 1.5300f, 0.3800f, 0.1122f, 0.0540f, { 0.0000f, 0.0000f, 0.0000f }, 0.6310f, 0.0520f, { 0.0000f, 0.0000f, 0.0000f }, 0.2260f, 0.1100f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_ICEPALACE_CUPBOARD \
+    { 1.0000f, 0.8300f, 0.3162f, 0.5012f, 0.2239f, 0.7600f, 1.5300f, 0.2600f, 1.1220f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.9953f, 0.0160f, { 0.0000f, 0.0000f, 0.0000f }, 0.1430f, 0.0800f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_ICEPALACE_COURTYARD \
+    { 1.0000f, 0.5900f, 0.3162f, 0.2818f, 0.3162f, 2.0400f, 1.2000f, 0.3800f, 0.3162f, 0.1730f, { 0.0000f, 0.0000f, 0.0000f }, 0.3162f, 0.0430f, { 0.0000f, 0.0000f, 0.0000f }, 0.2350f, 0.4800f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_ICEPALACE_ALCOVE \
+    { 1.0000f, 0.8400f, 0.3162f, 0.5623f, 0.2818f, 2.7600f, 1.4600f, 0.2800f, 1.1220f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 0.8913f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.1610f, 0.0900f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 }
+
+/* Space Station Presets */
+
+#define EFX_REVERB_PRESET_SPACESTATION_SMALLROOM \
+    { 0.2109f, 0.7000f, 0.3162f, 0.7079f, 0.8913f, 1.7200f, 0.8200f, 0.5500f, 0.7943f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0130f, { 0.0000f, 0.0000f, 0.0000f }, 0.1880f, 0.2600f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_SPACESTATION_SHORTPASSAGE \
+    { 0.2109f, 0.8700f, 0.3162f, 0.6310f, 0.8913f, 3.5700f, 0.5000f, 0.5500f, 1.0000f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0160f, { 0.0000f, 0.0000f, 0.0000f }, 0.1720f, 0.2000f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_SPACESTATION_MEDIUMROOM \
+    { 0.2109f, 0.7500f, 0.3162f, 0.6310f, 0.8913f, 3.0100f, 0.5000f, 0.5500f, 0.3981f, 0.0340f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0350f, { 0.0000f, 0.0000f, 0.0000f }, 0.2090f, 0.3100f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_SPACESTATION_LARGEROOM \
+    { 0.3645f, 0.8100f, 0.3162f, 0.6310f, 0.8913f, 3.8900f, 0.3800f, 0.6100f, 0.3162f, 0.0560f, { 0.0000f, 0.0000f, 0.0000f }, 0.8913f, 0.0350f, { 0.0000f, 0.0000f, 0.0000f }, 0.2330f, 0.2800f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_SPACESTATION_LONGPASSAGE \
+    { 0.4287f, 0.8200f, 0.3162f, 0.6310f, 0.8913f, 4.6200f, 0.6200f, 0.5500f, 1.0000f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0310f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.2300f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_SPACESTATION_HALL \
+    { 0.4287f, 0.8700f, 0.3162f, 0.6310f, 0.8913f, 7.1100f, 0.3800f, 0.6100f, 0.1778f, 0.1000f, { 0.0000f, 0.0000f, 0.0000f }, 0.6310f, 0.0470f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.2500f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_SPACESTATION_CUPBOARD \
+    { 0.1715f, 0.5600f, 0.3162f, 0.7079f, 0.8913f, 0.7900f, 0.8100f, 0.5500f, 1.4125f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.7783f, 0.0180f, { 0.0000f, 0.0000f, 0.0000f }, 0.1810f, 0.3100f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_SPACESTATION_ALCOVE \
+    { 0.2109f, 0.7800f, 0.3162f, 0.7079f, 0.8913f, 1.1600f, 0.8100f, 0.5500f, 1.4125f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.0000f, 0.0180f, { 0.0000f, 0.0000f, 0.0000f }, 0.1920f, 0.2100f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 }
+
+/* Wooden Galleon Presets */
+
+#define EFX_REVERB_PRESET_WOODEN_SMALLROOM \
+    { 1.0000f, 1.0000f, 0.3162f, 0.1122f, 0.3162f, 0.7900f, 0.3200f, 0.8700f, 1.0000f, 0.0320f, { 0.0000f, 0.0000f, 0.0000f }, 0.8913f, 0.0290f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_WOODEN_SHORTPASSAGE \
+    { 1.0000f, 1.0000f, 0.3162f, 0.1259f, 0.3162f, 1.7500f, 0.5000f, 0.8700f, 0.8913f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 0.6310f, 0.0240f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_WOODEN_MEDIUMROOM \
+    { 1.0000f, 1.0000f, 0.3162f, 0.1000f, 0.2818f, 1.4700f, 0.4200f, 0.8200f, 0.8913f, 0.0490f, { 0.0000f, 0.0000f, 0.0000f }, 0.8913f, 0.0290f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_WOODEN_LARGEROOM \
+    { 1.0000f, 1.0000f, 0.3162f, 0.0891f, 0.2818f, 2.6500f, 0.3300f, 0.8200f, 0.8913f, 0.0660f, { 0.0000f, 0.0000f, 0.0000f }, 0.7943f, 0.0490f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_WOODEN_LONGPASSAGE \
+    { 1.0000f, 1.0000f, 0.3162f, 0.1000f, 0.3162f, 1.9900f, 0.4000f, 0.7900f, 1.0000f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.4467f, 0.0360f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_WOODEN_HALL \
+    { 1.0000f, 1.0000f, 0.3162f, 0.0794f, 0.2818f, 3.4500f, 0.3000f, 0.8200f, 0.8913f, 0.0880f, { 0.0000f, 0.0000f, 0.0000f }, 0.7943f, 0.0630f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_WOODEN_CUPBOARD \
+    { 1.0000f, 1.0000f, 0.3162f, 0.1413f, 0.3162f, 0.5600f, 0.4600f, 0.9100f, 1.1220f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0280f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_WOODEN_COURTYARD \
+    { 1.0000f, 0.6500f, 0.3162f, 0.0794f, 0.3162f, 1.7900f, 0.3500f, 0.7900f, 0.5623f, 0.1230f, { 0.0000f, 0.0000f, 0.0000f }, 0.1000f, 0.0320f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_WOODEN_ALCOVE \
+    { 1.0000f, 1.0000f, 0.3162f, 0.1259f, 0.3162f, 1.2200f, 0.6200f, 0.9100f, 1.1220f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 0.7079f, 0.0240f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 }
+
+/* Sports Presets */
+
+#define EFX_REVERB_PRESET_SPORT_EMPTYSTADIUM \
+    { 1.0000f, 1.0000f, 0.3162f, 0.4467f, 0.7943f, 6.2600f, 0.5100f, 1.1000f, 0.0631f, 0.1830f, { 0.0000f, 0.0000f, 0.0000f }, 0.3981f, 0.0380f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_SPORT_SQUASHCOURT \
+    { 1.0000f, 0.7500f, 0.3162f, 0.3162f, 0.7943f, 2.2200f, 0.9100f, 1.1600f, 0.4467f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 0.7943f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.1260f, 0.1900f, 0.2500f, 0.0000f, 0.9943f, 7176.8999f, 211.2000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_SPORT_SMALLSWIMMINGPOOL \
+    { 1.0000f, 0.7000f, 0.3162f, 0.7943f, 0.8913f, 2.7600f, 1.2500f, 1.1400f, 0.6310f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.7943f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.1790f, 0.1500f, 0.8950f, 0.1900f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_SPORT_LARGESWIMMINGPOOL \
+    { 1.0000f, 0.8200f, 0.3162f, 0.7943f, 1.0000f, 5.4900f, 1.3100f, 1.1400f, 0.4467f, 0.0390f, { 0.0000f, 0.0000f, 0.0000f }, 0.5012f, 0.0490f, { 0.0000f, 0.0000f, 0.0000f }, 0.2220f, 0.5500f, 1.1590f, 0.2100f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_SPORT_GYMNASIUM \
+    { 1.0000f, 0.8100f, 0.3162f, 0.4467f, 0.8913f, 3.1400f, 1.0600f, 1.3500f, 0.3981f, 0.0290f, { 0.0000f, 0.0000f, 0.0000f }, 0.5623f, 0.0450f, { 0.0000f, 0.0000f, 0.0000f }, 0.1460f, 0.1400f, 0.2500f, 0.0000f, 0.9943f, 7176.8999f, 211.2000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_SPORT_FULLSTADIUM \
+    { 1.0000f, 1.0000f, 0.3162f, 0.0708f, 0.7943f, 5.2500f, 0.1700f, 0.8000f, 0.1000f, 0.1880f, { 0.0000f, 0.0000f, 0.0000f }, 0.2818f, 0.0380f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_SPORT_STADIUMTANNOY \
+    { 1.0000f, 0.7800f, 0.3162f, 0.5623f, 0.5012f, 2.5300f, 0.8800f, 0.6800f, 0.2818f, 0.2300f, { 0.0000f, 0.0000f, 0.0000f }, 0.5012f, 0.0630f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.2000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+/* Prefab Presets */
+
+#define EFX_REVERB_PRESET_PREFAB_WORKSHOP \
+    { 0.4287f, 1.0000f, 0.3162f, 0.1413f, 0.3981f, 0.7600f, 1.0000f, 1.0000f, 1.0000f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_PREFAB_SCHOOLROOM \
+    { 0.4022f, 0.6900f, 0.3162f, 0.6310f, 0.5012f, 0.9800f, 0.4500f, 0.1800f, 1.4125f, 0.0170f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0150f, { 0.0000f, 0.0000f, 0.0000f }, 0.0950f, 0.1400f, 0.2500f, 0.0000f, 0.9943f, 7176.8999f, 211.2000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_PREFAB_PRACTISEROOM \
+    { 0.4022f, 0.8700f, 0.3162f, 0.3981f, 0.5012f, 1.1200f, 0.5600f, 0.1800f, 1.2589f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.0950f, 0.1400f, 0.2500f, 0.0000f, 0.9943f, 7176.8999f, 211.2000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_PREFAB_OUTHOUSE \
+    { 1.0000f, 0.8200f, 0.3162f, 0.1122f, 0.1585f, 1.3800f, 0.3800f, 0.3500f, 0.8913f, 0.0240f, { 0.0000f, 0.0000f, -0.0000f }, 0.6310f, 0.0440f, { 0.0000f, 0.0000f, 0.0000f }, 0.1210f, 0.1700f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 107.5000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_PREFAB_CARAVAN \
+    { 1.0000f, 1.0000f, 0.3162f, 0.0891f, 0.1259f, 0.4300f, 1.5000f, 1.0000f, 1.0000f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.9953f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
+
+/* Dome and Pipe Presets */
+
+#define EFX_REVERB_PRESET_DOME_TOMB \
+    { 1.0000f, 0.7900f, 0.3162f, 0.3548f, 0.2239f, 4.1800f, 0.2100f, 0.1000f, 0.3868f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 1.6788f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 0.1770f, 0.1900f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 20.0000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_PIPE_SMALL \
+    { 1.0000f, 1.0000f, 0.3162f, 0.3548f, 0.2239f, 5.0400f, 0.1000f, 0.1000f, 0.5012f, 0.0320f, { 0.0000f, 0.0000f, 0.0000f }, 2.5119f, 0.0150f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 20.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_DOME_SAINTPAULS \
+    { 1.0000f, 0.8700f, 0.3162f, 0.3548f, 0.2239f, 10.4800f, 0.1900f, 0.1000f, 0.1778f, 0.0900f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0420f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.1200f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 20.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_PIPE_LONGTHIN \
+    { 0.2560f, 0.9100f, 0.3162f, 0.4467f, 0.2818f, 9.2100f, 0.1800f, 0.1000f, 0.7079f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 0.7079f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 20.0000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_PIPE_LARGE \
+    { 1.0000f, 1.0000f, 0.3162f, 0.3548f, 0.2239f, 8.4500f, 0.1000f, 0.1000f, 0.3981f, 0.0460f, { 0.0000f, 0.0000f, 0.0000f }, 1.5849f, 0.0320f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 20.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_PIPE_RESONANT \
+    { 0.1373f, 0.9100f, 0.3162f, 0.4467f, 0.2818f, 6.8100f, 0.1800f, 0.1000f, 0.7079f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.0000f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 20.0000f, 0.0000f, 0x0 }
+
+/* Outdoors Presets */
+
+#define EFX_REVERB_PRESET_OUTDOORS_BACKYARD \
+    { 1.0000f, 0.4500f, 0.3162f, 0.2512f, 0.5012f, 1.1200f, 0.3400f, 0.4600f, 0.4467f, 0.0690f, { 0.0000f, 0.0000f, -0.0000f }, 0.7079f, 0.0230f, { 0.0000f, 0.0000f, 0.0000f }, 0.2180f, 0.3400f, 0.2500f, 0.0000f, 0.9943f, 4399.1001f, 242.9000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_OUTDOORS_ROLLINGPLAINS \
+    { 1.0000f, 0.0000f, 0.3162f, 0.0112f, 0.6310f, 2.1300f, 0.2100f, 0.4600f, 0.1778f, 0.3000f, { 0.0000f, 0.0000f, -0.0000f }, 0.4467f, 0.0190f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.2500f, 0.0000f, 0.9943f, 4399.1001f, 242.9000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_OUTDOORS_DEEPCANYON \
+    { 1.0000f, 0.7400f, 0.3162f, 0.1778f, 0.6310f, 3.8900f, 0.2100f, 0.4600f, 0.3162f, 0.2230f, { 0.0000f, 0.0000f, -0.0000f }, 0.3548f, 0.0190f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.2500f, 0.0000f, 0.9943f, 4399.1001f, 242.9000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_OUTDOORS_CREEK \
+    { 1.0000f, 0.3500f, 0.3162f, 0.1778f, 0.5012f, 2.1300f, 0.2100f, 0.4600f, 0.3981f, 0.1150f, { 0.0000f, 0.0000f, -0.0000f }, 0.1995f, 0.0310f, { 0.0000f, 0.0000f, 0.0000f }, 0.2180f, 0.3400f, 0.2500f, 0.0000f, 0.9943f, 4399.1001f, 242.9000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_OUTDOORS_VALLEY \
+    { 1.0000f, 0.2800f, 0.3162f, 0.0282f, 0.1585f, 2.8800f, 0.2600f, 0.3500f, 0.1413f, 0.2630f, { 0.0000f, 0.0000f, -0.0000f }, 0.3981f, 0.1000f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.3400f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 107.5000f, 0.0000f, 0x0 }
+
+/* Mood Presets */
+
+#define EFX_REVERB_PRESET_MOOD_HEAVEN \
+    { 1.0000f, 0.9400f, 0.3162f, 0.7943f, 0.4467f, 5.0400f, 1.1200f, 0.5600f, 0.2427f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0290f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0800f, 2.7420f, 0.0500f, 0.9977f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_MOOD_HELL \
+    { 1.0000f, 0.5700f, 0.3162f, 0.3548f, 0.4467f, 3.5700f, 0.4900f, 2.0000f, 0.0000f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.1100f, 0.0400f, 2.1090f, 0.5200f, 0.9943f, 5000.0000f, 139.5000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_MOOD_MEMORY \
+    { 1.0000f, 0.8500f, 0.3162f, 0.6310f, 0.3548f, 4.0600f, 0.8200f, 0.5600f, 0.0398f, 0.0000f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0000f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.4740f, 0.4500f, 0.9886f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
+
+/* Driving Presets */
+
+#define EFX_REVERB_PRESET_DRIVING_COMMENTATOR \
+    { 1.0000f, 0.0000f, 3.1623f, 0.5623f, 0.5012f, 2.4200f, 0.8800f, 0.6800f, 0.1995f, 0.0930f, { 0.0000f, 0.0000f, 0.0000f }, 0.2512f, 0.0170f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.2500f, 0.0000f, 0.9886f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_DRIVING_PITGARAGE \
+    { 0.4287f, 0.5900f, 0.3162f, 0.7079f, 0.5623f, 1.7200f, 0.9300f, 0.8700f, 0.5623f, 0.0000f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0160f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.1100f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_DRIVING_INCAR_RACER \
+    { 0.0832f, 0.8000f, 0.3162f, 1.0000f, 0.7943f, 0.1700f, 2.0000f, 0.4100f, 1.7783f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 0.7079f, 0.0150f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 10268.2002f, 251.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_DRIVING_INCAR_SPORTS \
+    { 0.0832f, 0.8000f, 0.3162f, 0.6310f, 1.0000f, 0.1700f, 0.7500f, 0.4100f, 1.0000f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 0.5623f, 0.0000f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 10268.2002f, 251.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_DRIVING_INCAR_LUXURY \
+    { 0.2560f, 1.0000f, 0.3162f, 0.1000f, 0.5012f, 0.1300f, 0.4100f, 0.4600f, 0.7943f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.5849f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 10268.2002f, 251.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_DRIVING_FULLGRANDSTAND \
+    { 1.0000f, 1.0000f, 0.3162f, 0.2818f, 0.6310f, 3.0100f, 1.3700f, 1.2800f, 0.3548f, 0.0900f, { 0.0000f, 0.0000f, 0.0000f }, 0.1778f, 0.0490f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 10420.2002f, 250.0000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_DRIVING_EMPTYGRANDSTAND \
+    { 1.0000f, 1.0000f, 0.3162f, 1.0000f, 0.7943f, 4.6200f, 1.7500f, 1.4000f, 0.2082f, 0.0900f, { 0.0000f, 0.0000f, 0.0000f }, 0.2512f, 0.0490f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 10420.2002f, 250.0000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_DRIVING_TUNNEL \
+    { 1.0000f, 0.8100f, 0.3162f, 0.3981f, 0.8913f, 3.4200f, 0.9400f, 1.3100f, 0.7079f, 0.0510f, { 0.0000f, 0.0000f, 0.0000f }, 0.7079f, 0.0470f, { 0.0000f, 0.0000f, 0.0000f }, 0.2140f, 0.0500f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 155.3000f, 0.0000f, 0x1 }
+
+/* City Presets */
+
+#define EFX_REVERB_PRESET_CITY_STREETS \
+    { 1.0000f, 0.7800f, 0.3162f, 0.7079f, 0.8913f, 1.7900f, 1.1200f, 0.9100f, 0.2818f, 0.0460f, { 0.0000f, 0.0000f, 0.0000f }, 0.1995f, 0.0280f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.2000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_CITY_SUBWAY \
+    { 1.0000f, 0.7400f, 0.3162f, 0.7079f, 0.8913f, 3.0100f, 1.2300f, 0.9100f, 0.7079f, 0.0460f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0280f, { 0.0000f, 0.0000f, 0.0000f }, 0.1250f, 0.2100f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_CITY_MUSEUM \
+    { 1.0000f, 0.8200f, 0.3162f, 0.1778f, 0.1778f, 3.2800f, 1.4000f, 0.5700f, 0.2512f, 0.0390f, { 0.0000f, 0.0000f, -0.0000f }, 0.8913f, 0.0340f, { 0.0000f, 0.0000f, 0.0000f }, 0.1300f, 0.1700f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 107.5000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_CITY_LIBRARY \
+    { 1.0000f, 0.8200f, 0.3162f, 0.2818f, 0.0891f, 2.7600f, 0.8900f, 0.4100f, 0.3548f, 0.0290f, { 0.0000f, 0.0000f, -0.0000f }, 0.8913f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.1300f, 0.1700f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 107.5000f, 0.0000f, 0x0 }
+
+#define EFX_REVERB_PRESET_CITY_UNDERPASS \
+    { 1.0000f, 0.8200f, 0.3162f, 0.4467f, 0.8913f, 3.5700f, 1.1200f, 0.9100f, 0.3981f, 0.0590f, { 0.0000f, 0.0000f, 0.0000f }, 0.8913f, 0.0370f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.1400f, 0.2500f, 0.0000f, 0.9920f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_CITY_ABANDONED \
+    { 1.0000f, 0.6900f, 0.3162f, 0.7943f, 0.8913f, 3.2800f, 1.1700f, 0.9100f, 0.4467f, 0.0440f, { 0.0000f, 0.0000f, 0.0000f }, 0.2818f, 0.0240f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.2000f, 0.2500f, 0.0000f, 0.9966f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+/* Misc. Presets */
+
+#define EFX_REVERB_PRESET_DUSTYROOM \
+    { 0.3645f, 0.5600f, 0.3162f, 0.7943f, 0.7079f, 1.7900f, 0.3800f, 0.2100f, 0.5012f, 0.0020f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0060f, { 0.0000f, 0.0000f, 0.0000f }, 0.2020f, 0.0500f, 0.2500f, 0.0000f, 0.9886f, 13046.0000f, 163.3000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_CHAPEL \
+    { 1.0000f, 0.8400f, 0.3162f, 0.5623f, 1.0000f, 4.6200f, 0.6400f, 1.2300f, 0.4467f, 0.0320f, { 0.0000f, 0.0000f, 0.0000f }, 0.7943f, 0.0490f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.1100f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 }
+
+#define EFX_REVERB_PRESET_SMALLWATERROOM \
+    { 1.0000f, 0.7000f, 0.3162f, 0.4477f, 1.0000f, 1.5100f, 1.2500f, 1.1400f, 0.8913f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.1790f, 0.1500f, 0.8950f, 0.1900f, 0.9920f, 5000.0000f, 250.0000f, 0.0000f, 0x0 }
+
+#endif /* EFX_PRESETS_H */

OpenAL/include/efx.h

@@ -0,0 +1,761 @@
+#ifndef AL_EFX_H
+#define AL_EFX_H
+
+
+#include "alc.h"
+#include "al.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ALC_EXT_EFX_NAME                         "ALC_EXT_EFX"
+
+#define ALC_EFX_MAJOR_VERSION                    0x20001
+#define ALC_EFX_MINOR_VERSION                    0x20002
+#define ALC_MAX_AUXILIARY_SENDS                  0x20003
+
+
+/* Listener properties. */
+#define AL_METERS_PER_UNIT                       0x20004
+
+/* Source properties. */
+#define AL_DIRECT_FILTER                         0x20005
+#define AL_AUXILIARY_SEND_FILTER                 0x20006
+#define AL_AIR_ABSORPTION_FACTOR                 0x20007
+#define AL_ROOM_ROLLOFF_FACTOR                   0x20008
+#define AL_CONE_OUTER_GAINHF                     0x20009
+#define AL_DIRECT_FILTER_GAINHF_AUTO             0x2000A
+#define AL_AUXILIARY_SEND_FILTER_GAIN_AUTO       0x2000B
+#define AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO     0x2000C
+
+
+/* Effect properties. */
+
+/* Reverb effect parameters */
+#define AL_REVERB_DENSITY                        0x0001
+#define AL_REVERB_DIFFUSION                      0x0002
+#define AL_REVERB_GAIN                           0x0003
+#define AL_REVERB_GAINHF                         0x0004
+#define AL_REVERB_DECAY_TIME                     0x0005
+#define AL_REVERB_DECAY_HFRATIO                  0x0006
+#define AL_REVERB_REFLECTIONS_GAIN               0x0007
+#define AL_REVERB_REFLECTIONS_DELAY              0x0008
+#define AL_REVERB_LATE_REVERB_GAIN               0x0009
+#define AL_REVERB_LATE_REVERB_DELAY              0x000A
+#define AL_REVERB_AIR_ABSORPTION_GAINHF          0x000B
+#define AL_REVERB_ROOM_ROLLOFF_FACTOR            0x000C
+#define AL_REVERB_DECAY_HFLIMIT                  0x000D
+
+/* EAX Reverb effect parameters */
+#define AL_EAXREVERB_DENSITY                     0x0001
+#define AL_EAXREVERB_DIFFUSION                   0x0002
+#define AL_EAXREVERB_GAIN                        0x0003
+#define AL_EAXREVERB_GAINHF                      0x0004
+#define AL_EAXREVERB_GAINLF                      0x0005
+#define AL_EAXREVERB_DECAY_TIME                  0x0006
+#define AL_EAXREVERB_DECAY_HFRATIO               0x0007
+#define AL_EAXREVERB_DECAY_LFRATIO               0x0008
+#define AL_EAXREVERB_REFLECTIONS_GAIN            0x0009
+#define AL_EAXREVERB_REFLECTIONS_DELAY           0x000A
+#define AL_EAXREVERB_REFLECTIONS_PAN             0x000B
+#define AL_EAXREVERB_LATE_REVERB_GAIN            0x000C
+#define AL_EAXREVERB_LATE_REVERB_DELAY           0x000D
+#define AL_EAXREVERB_LATE_REVERB_PAN             0x000E
+#define AL_EAXREVERB_ECHO_TIME                   0x000F
+#define AL_EAXREVERB_ECHO_DEPTH                  0x0010
+#define AL_EAXREVERB_MODULATION_TIME             0x0011
+#define AL_EAXREVERB_MODULATION_DEPTH            0x0012
+#define AL_EAXREVERB_AIR_ABSORPTION_GAINHF       0x0013
+#define AL_EAXREVERB_HFREFERENCE                 0x0014
+#define AL_EAXREVERB_LFREFERENCE                 0x0015
+#define AL_EAXREVERB_ROOM_ROLLOFF_FACTOR         0x0016
+#define AL_EAXREVERB_DECAY_HFLIMIT               0x0017
+
+/* Chorus effect parameters */
+#define AL_CHORUS_WAVEFORM                       0x0001
+#define AL_CHORUS_PHASE                          0x0002
+#define AL_CHORUS_RATE                           0x0003
+#define AL_CHORUS_DEPTH                          0x0004
+#define AL_CHORUS_FEEDBACK                       0x0005
+#define AL_CHORUS_DELAY                          0x0006
+
+/* Distortion effect parameters */
+#define AL_DISTORTION_EDGE                       0x0001
+#define AL_DISTORTION_GAIN                       0x0002
+#define AL_DISTORTION_LOWPASS_CUTOFF             0x0003
+#define AL_DISTORTION_EQCENTER                   0x0004
+#define AL_DISTORTION_EQBANDWIDTH                0x0005
+
+/* Echo effect parameters */
+#define AL_ECHO_DELAY                            0x0001
+#define AL_ECHO_LRDELAY                          0x0002
+#define AL_ECHO_DAMPING                          0x0003
+#define AL_ECHO_FEEDBACK                         0x0004
+#define AL_ECHO_SPREAD                           0x0005
+
+/* Flanger effect parameters */
+#define AL_FLANGER_WAVEFORM                      0x0001
+#define AL_FLANGER_PHASE                         0x0002
+#define AL_FLANGER_RATE                          0x0003
+#define AL_FLANGER_DEPTH                         0x0004
+#define AL_FLANGER_FEEDBACK                      0x0005
+#define AL_FLANGER_DELAY                         0x0006
+
+/* Frequency shifter effect parameters */
+#define AL_FREQUENCY_SHIFTER_FREQUENCY           0x0001
+#define AL_FREQUENCY_SHIFTER_LEFT_DIRECTION      0x0002
+#define AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION     0x0003
+
+/* Vocal morpher effect parameters */
+#define AL_VOCAL_MORPHER_PHONEMEA                0x0001
+#define AL_VOCAL_MORPHER_PHONEMEA_COARSE_TUNING  0x0002
+#define AL_VOCAL_MORPHER_PHONEMEB                0x0003
+#define AL_VOCAL_MORPHER_PHONEMEB_COARSE_TUNING  0x0004
+#define AL_VOCAL_MORPHER_WAVEFORM                0x0005
+#define AL_VOCAL_MORPHER_RATE                    0x0006
+
+/* Pitchshifter effect parameters */
+#define AL_PITCH_SHIFTER_COARSE_TUNE             0x0001
+#define AL_PITCH_SHIFTER_FINE_TUNE               0x0002
+
+/* Ringmodulator effect parameters */
+#define AL_RING_MODULATOR_FREQUENCY              0x0001
+#define AL_RING_MODULATOR_HIGHPASS_CUTOFF        0x0002
+#define AL_RING_MODULATOR_WAVEFORM               0x0003
+
+/* Autowah effect parameters */
+#define AL_AUTOWAH_ATTACK_TIME                   0x0001
+#define AL_AUTOWAH_RELEASE_TIME                  0x0002
+#define AL_AUTOWAH_RESONANCE                     0x0003
+#define AL_AUTOWAH_PEAK_GAIN                     0x0004
+
+/* Compressor effect parameters */
+#define AL_COMPRESSOR_ONOFF                      0x0001
+
+/* Equalizer effect parameters */
+#define AL_EQUALIZER_LOW_GAIN                    0x0001
+#define AL_EQUALIZER_LOW_CUTOFF                  0x0002
+#define AL_EQUALIZER_MID1_GAIN                   0x0003
+#define AL_EQUALIZER_MID1_CENTER                 0x0004
+#define AL_EQUALIZER_MID1_WIDTH                  0x0005
+#define AL_EQUALIZER_MID2_GAIN                   0x0006
+#define AL_EQUALIZER_MID2_CENTER                 0x0007
+#define AL_EQUALIZER_MID2_WIDTH                  0x0008
+#define AL_EQUALIZER_HIGH_GAIN                   0x0009
+#define AL_EQUALIZER_HIGH_CUTOFF                 0x000A
+
+/* Effect type */
+#define AL_EFFECT_FIRST_PARAMETER                0x0000
+#define AL_EFFECT_LAST_PARAMETER                 0x8000
+#define AL_EFFECT_TYPE                           0x8001
+
+/* Effect types, used with the AL_EFFECT_TYPE property */
+#define AL_EFFECT_NULL                           0x0000
+#define AL_EFFECT_REVERB                         0x0001
+#define AL_EFFECT_CHORUS                         0x0002
+#define AL_EFFECT_DISTORTION                     0x0003
+#define AL_EFFECT_ECHO                           0x0004
+#define AL_EFFECT_FLANGER                        0x0005
+#define AL_EFFECT_FREQUENCY_SHIFTER              0x0006
+#define AL_EFFECT_VOCAL_MORPHER                  0x0007
+#define AL_EFFECT_PITCH_SHIFTER                  0x0008
+#define AL_EFFECT_RING_MODULATOR                 0x0009
+#define AL_EFFECT_AUTOWAH                        0x000A
+#define AL_EFFECT_COMPRESSOR                     0x000B
+#define AL_EFFECT_EQUALIZER                      0x000C
+#define AL_EFFECT_EAXREVERB                      0x8000
+
+/* Auxiliary Effect Slot properties. */
+#define AL_EFFECTSLOT_EFFECT                     0x0001
+#define AL_EFFECTSLOT_GAIN                       0x0002
+#define AL_EFFECTSLOT_AUXILIARY_SEND_AUTO        0x0003
+
+/* NULL Auxiliary Slot ID to disable a source send. */
+#define AL_EFFECTSLOT_NULL                       0x0000
+
+
+/* Filter properties. */
+
+/* Lowpass filter parameters */
+#define AL_LOWPASS_GAIN                          0x0001
+#define AL_LOWPASS_GAINHF                        0x0002
+
+/* Highpass filter parameters */
+#define AL_HIGHPASS_GAIN                         0x0001
+#define AL_HIGHPASS_GAINLF                       0x0002
+
+/* Bandpass filter parameters */
+#define AL_BANDPASS_GAIN                         0x0001
+#define AL_BANDPASS_GAINLF                       0x0002
+#define AL_BANDPASS_GAINHF                       0x0003
+
+/* Filter type */
+#define AL_FILTER_FIRST_PARAMETER                0x0000
+#define AL_FILTER_LAST_PARAMETER                 0x8000
+#define AL_FILTER_TYPE                           0x8001
+
+/* Filter types, used with the AL_FILTER_TYPE property */
+#define AL_FILTER_NULL                           0x0000
+#define AL_FILTER_LOWPASS                        0x0001
+#define AL_FILTER_HIGHPASS                       0x0002
+#define AL_FILTER_BANDPASS                       0x0003
+
+
+/* Effect object function types. */
+typedef void (AL_APIENTRY *LPALGENEFFECTS)(ALsizei, ALuint*);
+typedef void (AL_APIENTRY *LPALDELETEEFFECTS)(ALsizei, const ALuint*);
+typedef ALboolean (AL_APIENTRY *LPALISEFFECT)(ALuint);
+typedef void (AL_APIENTRY *LPALEFFECTI)(ALuint, ALenum, ALint);
+typedef void (AL_APIENTRY *LPALEFFECTIV)(ALuint, ALenum, const ALint*);
+typedef void (AL_APIENTRY *LPALEFFECTF)(ALuint, ALenum, ALfloat);
+typedef void (AL_APIENTRY *LPALEFFECTFV)(ALuint, ALenum, const ALfloat*);
+typedef void (AL_APIENTRY *LPALGETEFFECTI)(ALuint, ALenum, ALint*);
+typedef void (AL_APIENTRY *LPALGETEFFECTIV)(ALuint, ALenum, ALint*);
+typedef void (AL_APIENTRY *LPALGETEFFECTF)(ALuint, ALenum, ALfloat*);
+typedef void (AL_APIENTRY *LPALGETEFFECTFV)(ALuint, ALenum, ALfloat*);
+
+/* Filter object function types. */
+typedef void (AL_APIENTRY *LPALGENFILTERS)(ALsizei, ALuint*);
+typedef void (AL_APIENTRY *LPALDELETEFILTERS)(ALsizei, const ALuint*);
+typedef ALboolean (AL_APIENTRY *LPALISFILTER)(ALuint);
+typedef void (AL_APIENTRY *LPALFILTERI)(ALuint, ALenum, ALint);
+typedef void (AL_APIENTRY *LPALFILTERIV)(ALuint, ALenum, const ALint*);
+typedef void (AL_APIENTRY *LPALFILTERF)(ALuint, ALenum, ALfloat);
+typedef void (AL_APIENTRY *LPALFILTERFV)(ALuint, ALenum, const ALfloat*);
+typedef void (AL_APIENTRY *LPALGETFILTERI)(ALuint, ALenum, ALint*);
+typedef void (AL_APIENTRY *LPALGETFILTERIV)(ALuint, ALenum, ALint*);
+typedef void (AL_APIENTRY *LPALGETFILTERF)(ALuint, ALenum, ALfloat*);
+typedef void (AL_APIENTRY *LPALGETFILTERFV)(ALuint, ALenum, ALfloat*);
+
+/* Auxiliary Effect Slot object function types. */
+typedef void (AL_APIENTRY *LPALGENAUXILIARYEFFECTSLOTS)(ALsizei, ALuint*);
+typedef void (AL_APIENTRY *LPALDELETEAUXILIARYEFFECTSLOTS)(ALsizei, const ALuint*);
+typedef ALboolean (AL_APIENTRY *LPALISAUXILIARYEFFECTSLOT)(ALuint);
+typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTI)(ALuint, ALenum, ALint);
+typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTIV)(ALuint, ALenum, const ALint*);
+typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTF)(ALuint, ALenum, ALfloat);
+typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTFV)(ALuint, ALenum, const ALfloat*);
+typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTI)(ALuint, ALenum, ALint*);
+typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTIV)(ALuint, ALenum, ALint*);
+typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTF)(ALuint, ALenum, ALfloat*);
+typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTFV)(ALuint, ALenum, ALfloat*);
+
+#ifdef AL_ALEXT_PROTOTYPES
+AL_API ALvoid AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects);
+AL_API ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, const ALuint *effects);
+AL_API ALboolean AL_APIENTRY alIsEffect(ALuint effect);
+AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue);
+AL_API ALvoid AL_APIENTRY alEffectiv(ALuint effect, ALenum param, const ALint *piValues);
+AL_API ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue);
+AL_API ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, const ALfloat *pflValues);
+AL_API ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *piValue);
+AL_API ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piValues);
+AL_API ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue);
+AL_API ALvoid AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *pflValues);
+
+AL_API ALvoid AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters);
+AL_API ALvoid AL_APIENTRY alDeleteFilters(ALsizei n, const ALuint *filters);
+AL_API ALboolean AL_APIENTRY alIsFilter(ALuint filter);
+AL_API ALvoid AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint iValue);
+AL_API ALvoid AL_APIENTRY alFilteriv(ALuint filter, ALenum param, const ALint *piValues);
+AL_API ALvoid AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue);
+AL_API ALvoid AL_APIENTRY alFilterfv(ALuint filter, ALenum param, const ALfloat *pflValues);
+AL_API ALvoid AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *piValue);
+AL_API ALvoid AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *piValues);
+AL_API ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue);
+AL_API ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pflValues);
+
+AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots);
+AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, const ALuint *effectslots);
+AL_API ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot);
+AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue);
+AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, const ALint *piValues);
+AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat flValue);
+AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, const ALfloat *pflValues);
+AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *piValue);
+AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues);
+AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *pflValue);
+AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues);
+#endif
+
+/* Filter ranges and defaults. */
+
+/* Lowpass filter */
+#define AL_LOWPASS_MIN_GAIN                      (0.0f)
+#define AL_LOWPASS_MAX_GAIN                      (1.0f)
+#define AL_LOWPASS_DEFAULT_GAIN                  (1.0f)
+
+#define AL_LOWPASS_MIN_GAINHF                    (0.0f)
+#define AL_LOWPASS_MAX_GAINHF                    (1.0f)
+#define AL_LOWPASS_DEFAULT_GAINHF                (1.0f)
+
+/* Highpass filter */
+#define AL_HIGHPASS_MIN_GAIN                     (0.0f)
+#define AL_HIGHPASS_MAX_GAIN                     (1.0f)
+#define AL_HIGHPASS_DEFAULT_GAIN                 (1.0f)
+
+#define AL_HIGHPASS_MIN_GAINLF                   (0.0f)
+#define AL_HIGHPASS_MAX_GAINLF                   (1.0f)
+#define AL_HIGHPASS_DEFAULT_GAINLF               (1.0f)
+
+/* Bandpass filter */
+#define AL_BANDPASS_MIN_GAIN                     (0.0f)
+#define AL_BANDPASS_MAX_GAIN                     (1.0f)
+#define AL_BANDPASS_DEFAULT_GAIN                 (1.0f)
+
+#define AL_BANDPASS_MIN_GAINHF                   (0.0f)
+#define AL_BANDPASS_MAX_GAINHF                   (1.0f)
+#define AL_BANDPASS_DEFAULT_GAINHF               (1.0f)
+
+#define AL_BANDPASS_MIN_GAINLF                   (0.0f)
+#define AL_BANDPASS_MAX_GAINLF                   (1.0f)
+#define AL_BANDPASS_DEFAULT_GAINLF               (1.0f)
+
+
+/* Effect parameter ranges and defaults. */
+
+/* Standard reverb effect */
+#define AL_REVERB_MIN_DENSITY                    (0.0f)
+#define AL_REVERB_MAX_DENSITY                    (1.0f)
+#define AL_REVERB_DEFAULT_DENSITY                (1.0f)
+
+#define AL_REVERB_MIN_DIFFUSION                  (0.0f)
+#define AL_REVERB_MAX_DIFFUSION                  (1.0f)
+#define AL_REVERB_DEFAULT_DIFFUSION              (1.0f)
+
+#define AL_REVERB_MIN_GAIN                       (0.0f)
+#define AL_REVERB_MAX_GAIN                       (1.0f)
+#define AL_REVERB_DEFAULT_GAIN                   (0.32f)
+
+#define AL_REVERB_MIN_GAINHF                     (0.0f)
+#define AL_REVERB_MAX_GAINHF                     (1.0f)
+#define AL_REVERB_DEFAULT_GAINHF                 (0.89f)
+
+#define AL_REVERB_MIN_DECAY_TIME                 (0.1f)
+#define AL_REVERB_MAX_DECAY_TIME                 (20.0f)
+#define AL_REVERB_DEFAULT_DECAY_TIME             (1.49f)
+
+#define AL_REVERB_MIN_DECAY_HFRATIO              (0.1f)
+#define AL_REVERB_MAX_DECAY_HFRATIO              (2.0f)
+#define AL_REVERB_DEFAULT_DECAY_HFRATIO          (0.83f)
+
+#define AL_REVERB_MIN_REFLECTIONS_GAIN           (0.0f)
+#define AL_REVERB_MAX_REFLECTIONS_GAIN           (3.16f)
+#define AL_REVERB_DEFAULT_REFLECTIONS_GAIN       (0.05f)
+
+#define AL_REVERB_MIN_REFLECTIONS_DELAY          (0.0f)
+#define AL_REVERB_MAX_REFLECTIONS_DELAY          (0.3f)
+#define AL_REVERB_DEFAULT_REFLECTIONS_DELAY      (0.007f)
+
+#define AL_REVERB_MIN_LATE_REVERB_GAIN           (0.0f)
+#define AL_REVERB_MAX_LATE_REVERB_GAIN           (10.0f)
+#define AL_REVERB_DEFAULT_LATE_REVERB_GAIN       (1.26f)
+
+#define AL_REVERB_MIN_LATE_REVERB_DELAY          (0.0f)
+#define AL_REVERB_MAX_LATE_REVERB_DELAY          (0.1f)
+#define AL_REVERB_DEFAULT_LATE_REVERB_DELAY      (0.011f)
+
+#define AL_REVERB_MIN_AIR_ABSORPTION_GAINHF      (0.892f)
+#define AL_REVERB_MAX_AIR_ABSORPTION_GAINHF      (1.0f)
+#define AL_REVERB_DEFAULT_AIR_ABSORPTION_GAINHF  (0.994f)
+
+#define AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR        (0.0f)
+#define AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR        (10.0f)
+#define AL_REVERB_DEFAULT_ROOM_ROLLOFF_FACTOR    (0.0f)
+
+#define AL_REVERB_MIN_DECAY_HFLIMIT              AL_FALSE
+#define AL_REVERB_MAX_DECAY_HFLIMIT              AL_TRUE
+#define AL_REVERB_DEFAULT_DECAY_HFLIMIT          AL_TRUE
+
+/* EAX reverb effect */
+#define AL_EAXREVERB_MIN_DENSITY                 (0.0f)
+#define AL_EAXREVERB_MAX_DENSITY                 (1.0f)
+#define AL_EAXREVERB_DEFAULT_DENSITY             (1.0f)
+
+#define AL_EAXREVERB_MIN_DIFFUSION               (0.0f)
+#define AL_EAXREVERB_MAX_DIFFUSION               (1.0f)
+#define AL_EAXREVERB_DEFAULT_DIFFUSION           (1.0f)
+
+#define AL_EAXREVERB_MIN_GAIN                    (0.0f)
+#define AL_EAXREVERB_MAX_GAIN                    (1.0f)
+#define AL_EAXREVERB_DEFAULT_GAIN                (0.32f)
+
+#define AL_EAXREVERB_MIN_GAINHF                  (0.0f)
+#define AL_EAXREVERB_MAX_GAINHF                  (1.0f)
+#define AL_EAXREVERB_DEFAULT_GAINHF              (0.89f)
+
+#define AL_EAXREVERB_MIN_GAINLF                  (0.0f)
+#define AL_EAXREVERB_MAX_GAINLF                  (1.0f)
+#define AL_EAXREVERB_DEFAULT_GAINLF              (1.0f)
+
+#define AL_EAXREVERB_MIN_DECAY_TIME              (0.1f)
+#define AL_EAXREVERB_MAX_DECAY_TIME              (20.0f)
+#define AL_EAXREVERB_DEFAULT_DECAY_TIME          (1.49f)
+
+#define AL_EAXREVERB_MIN_DECAY_HFRATIO           (0.1f)
+#define AL_EAXREVERB_MAX_DECAY_HFRATIO           (2.0f)
+#define AL_EAXREVERB_DEFAULT_DECAY_HFRATIO       (0.83f)
+
+#define AL_EAXREVERB_MIN_DECAY_LFRATIO           (0.1f)
+#define AL_EAXREVERB_MAX_DECAY_LFRATIO           (2.0f)
+#define AL_EAXREVERB_DEFAULT_DECAY_LFRATIO       (1.0f)
+
+#define AL_EAXREVERB_MIN_REFLECTIONS_GAIN        (0.0f)
+#define AL_EAXREVERB_MAX_REFLECTIONS_GAIN        (3.16f)
+#define AL_EAXREVERB_DEFAULT_REFLECTIONS_GAIN    (0.05f)
+
+#define AL_EAXREVERB_MIN_REFLECTIONS_DELAY       (0.0f)
+#define AL_EAXREVERB_MAX_REFLECTIONS_DELAY       (0.3f)
+#define AL_EAXREVERB_DEFAULT_REFLECTIONS_DELAY   (0.007f)
+
+#define AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ (0.0f)
+
+#define AL_EAXREVERB_MIN_LATE_REVERB_GAIN        (0.0f)
+#define AL_EAXREVERB_MAX_LATE_REVERB_GAIN        (10.0f)
+#define AL_EAXREVERB_DEFAULT_LATE_REVERB_GAIN    (1.26f)
+
+#define AL_EAXREVERB_MIN_LATE_REVERB_DELAY       (0.0f)
+#define AL_EAXREVERB_MAX_LATE_REVERB_DELAY       (0.1f)
+#define AL_EAXREVERB_DEFAULT_LATE_REVERB_DELAY   (0.011f)
+
+#define AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ (0.0f)
+
+#define AL_EAXREVERB_MIN_ECHO_TIME               (0.075f)
+#define AL_EAXREVERB_MAX_ECHO_TIME               (0.25f)
+#define AL_EAXREVERB_DEFAULT_ECHO_TIME           (0.25f)
+
+#define AL_EAXREVERB_MIN_ECHO_DEPTH              (0.0f)
+#define AL_EAXREVERB_MAX_ECHO_DEPTH              (1.0f)
+#define AL_EAXREVERB_DEFAULT_ECHO_DEPTH          (0.0f)
+
+#define AL_EAXREVERB_MIN_MODULATION_TIME         (0.04f)
+#define AL_EAXREVERB_MAX_MODULATION_TIME         (4.0f)
+#define AL_EAXREVERB_DEFAULT_MODULATION_TIME     (0.25f)
+
+#define AL_EAXREVERB_MIN_MODULATION_DEPTH        (0.0f)
+#define AL_EAXREVERB_MAX_MODULATION_DEPTH        (1.0f)
+#define AL_EAXREVERB_DEFAULT_MODULATION_DEPTH    (0.0f)
+
+#define AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF   (0.892f)
+#define AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF   (1.0f)
+#define AL_EAXREVERB_DEFAULT_AIR_ABSORPTION_GAINHF (0.994f)
+
+#define AL_EAXREVERB_MIN_HFREFERENCE             (1000.0f)
+#define AL_EAXREVERB_MAX_HFREFERENCE             (20000.0f)
+#define AL_EAXREVERB_DEFAULT_HFREFERENCE         (5000.0f)
+
+#define AL_EAXREVERB_MIN_LFREFERENCE             (20.0f)
+#define AL_EAXREVERB_MAX_LFREFERENCE             (1000.0f)
+#define AL_EAXREVERB_DEFAULT_LFREFERENCE         (250.0f)
+
+#define AL_EAXREVERB_MIN_ROOM_ROLLOFF_FACTOR     (0.0f)
+#define AL_EAXREVERB_MAX_ROOM_ROLLOFF_FACTOR     (10.0f)
+#define AL_EAXREVERB_DEFAULT_ROOM_ROLLOFF_FACTOR (0.0f)
+
+#define AL_EAXREVERB_MIN_DECAY_HFLIMIT           AL_FALSE
+#define AL_EAXREVERB_MAX_DECAY_HFLIMIT           AL_TRUE
+#define AL_EAXREVERB_DEFAULT_DECAY_HFLIMIT       AL_TRUE
+
+/* Chorus effect */
+#define AL_CHORUS_WAVEFORM_SINUSOID              (0)
+#define AL_CHORUS_WAVEFORM_TRIANGLE              (1)
+
+#define AL_CHORUS_MIN_WAVEFORM                   (0)
+#define AL_CHORUS_MAX_WAVEFORM                   (1)
+#define AL_CHORUS_DEFAULT_WAVEFORM               (1)
+
+#define AL_CHORUS_MIN_PHASE                      (-180)
+#define AL_CHORUS_MAX_PHASE                      (180)
+#define AL_CHORUS_DEFAULT_PHASE                  (90)
+
+#define AL_CHORUS_MIN_RATE                       (0.0f)
+#define AL_CHORUS_MAX_RATE                       (10.0f)
+#define AL_CHORUS_DEFAULT_RATE                   (1.1f)
+
+#define AL_CHORUS_MIN_DEPTH                      (0.0f)
+#define AL_CHORUS_MAX_DEPTH                      (1.0f)
+#define AL_CHORUS_DEFAULT_DEPTH                  (0.1f)
+
+#define AL_CHORUS_MIN_FEEDBACK                   (-1.0f)
+#define AL_CHORUS_MAX_FEEDBACK                   (1.0f)
+#define AL_CHORUS_DEFAULT_FEEDBACK               (0.25f)
+
+#define AL_CHORUS_MIN_DELAY                      (0.0f)
+#define AL_CHORUS_MAX_DELAY                      (0.016f)
+#define AL_CHORUS_DEFAULT_DELAY                  (0.016f)
+
+/* Distortion effect */
+#define AL_DISTORTION_MIN_EDGE                   (0.0f)
+#define AL_DISTORTION_MAX_EDGE                   (1.0f)
+#define AL_DISTORTION_DEFAULT_EDGE               (0.2f)
+
+#define AL_DISTORTION_MIN_GAIN                   (0.01f)
+#define AL_DISTORTION_MAX_GAIN                   (1.0f)
+#define AL_DISTORTION_DEFAULT_GAIN               (0.05f)
+
+#define AL_DISTORTION_MIN_LOWPASS_CUTOFF         (80.0f)
+#define AL_DISTORTION_MAX_LOWPASS_CUTOFF         (24000.0f)
+#define AL_DISTORTION_DEFAULT_LOWPASS_CUTOFF     (8000.0f)
+
+#define AL_DISTORTION_MIN_EQCENTER               (80.0f)
+#define AL_DISTORTION_MAX_EQCENTER               (24000.0f)
+#define AL_DISTORTION_DEFAULT_EQCENTER           (3600.0f)
+
+#define AL_DISTORTION_MIN_EQBANDWIDTH            (80.0f)
+#define AL_DISTORTION_MAX_EQBANDWIDTH            (24000.0f)
+#define AL_DISTORTION_DEFAULT_EQBANDWIDTH        (3600.0f)
+
+/* Echo effect */
+#define AL_ECHO_MIN_DELAY                        (0.0f)
+#define AL_ECHO_MAX_DELAY                        (0.207f)
+#define AL_ECHO_DEFAULT_DELAY                    (0.1f)
+
+#define AL_ECHO_MIN_LRDELAY                      (0.0f)
+#define AL_ECHO_MAX_LRDELAY                      (0.404f)
+#define AL_ECHO_DEFAULT_LRDELAY                  (0.1f)
+
+#define AL_ECHO_MIN_DAMPING                      (0.0f)
+#define AL_ECHO_MAX_DAMPING                      (0.99f)
+#define AL_ECHO_DEFAULT_DAMPING                  (0.5f)
+
+#define AL_ECHO_MIN_FEEDBACK                     (0.0f)
+#define AL_ECHO_MAX_FEEDBACK                     (1.0f)
+#define AL_ECHO_DEFAULT_FEEDBACK                 (0.5f)
+
+#define AL_ECHO_MIN_SPREAD                       (-1.0f)
+#define AL_ECHO_MAX_SPREAD                       (1.0f)
+#define AL_ECHO_DEFAULT_SPREAD                   (-1.0f)
+
+/* Flanger effect */
+#define AL_FLANGER_WAVEFORM_SINUSOID             (0)
+#define AL_FLANGER_WAVEFORM_TRIANGLE             (1)
+
+#define AL_FLANGER_MIN_WAVEFORM                  (0)
+#define AL_FLANGER_MAX_WAVEFORM                  (1)
+#define AL_FLANGER_DEFAULT_WAVEFORM              (1)
+
+#define AL_FLANGER_MIN_PHASE                     (-180)
+#define AL_FLANGER_MAX_PHASE                     (180)
+#define AL_FLANGER_DEFAULT_PHASE                 (0)
+
+#define AL_FLANGER_MIN_RATE                      (0.0f)
+#define AL_FLANGER_MAX_RATE                      (10.0f)
+#define AL_FLANGER_DEFAULT_RATE                  (0.27f)
+
+#define AL_FLANGER_MIN_DEPTH                     (0.0f)
+#define AL_FLANGER_MAX_DEPTH                     (1.0f)
+#define AL_FLANGER_DEFAULT_DEPTH                 (1.0f)
+
+#define AL_FLANGER_MIN_FEEDBACK                  (-1.0f)
+#define AL_FLANGER_MAX_FEEDBACK                  (1.0f)
+#define AL_FLANGER_DEFAULT_FEEDBACK              (-0.5f)
+
+#define AL_FLANGER_MIN_DELAY                     (0.0f)
+#define AL_FLANGER_MAX_DELAY                     (0.004f)
+#define AL_FLANGER_DEFAULT_DELAY                 (0.002f)
+
+/* Frequency shifter effect */
+#define AL_FREQUENCY_SHIFTER_MIN_FREQUENCY       (0.0f)
+#define AL_FREQUENCY_SHIFTER_MAX_FREQUENCY       (24000.0f)
+#define AL_FREQUENCY_SHIFTER_DEFAULT_FREQUENCY   (0.0f)
+
+#define AL_FREQUENCY_SHIFTER_MIN_LEFT_DIRECTION  (0)
+#define AL_FREQUENCY_SHIFTER_MAX_LEFT_DIRECTION  (2)
+#define AL_FREQUENCY_SHIFTER_DEFAULT_LEFT_DIRECTION (0)
+
+#define AL_FREQUENCY_SHIFTER_DIRECTION_DOWN      (0)
+#define AL_FREQUENCY_SHIFTER_DIRECTION_UP        (1)
+#define AL_FREQUENCY_SHIFTER_DIRECTION_OFF       (2)
+
+#define AL_FREQUENCY_SHIFTER_MIN_RIGHT_DIRECTION (0)
+#define AL_FREQUENCY_SHIFTER_MAX_RIGHT_DIRECTION (2)
+#define AL_FREQUENCY_SHIFTER_DEFAULT_RIGHT_DIRECTION (0)
+
+/* Vocal morpher effect */
+#define AL_VOCAL_MORPHER_MIN_PHONEMEA            (0)
+#define AL_VOCAL_MORPHER_MAX_PHONEMEA            (29)
+#define AL_VOCAL_MORPHER_DEFAULT_PHONEMEA        (0)
+
+#define AL_VOCAL_MORPHER_MIN_PHONEMEA_COARSE_TUNING (-24)
+#define AL_VOCAL_MORPHER_MAX_PHONEMEA_COARSE_TUNING (24)
+#define AL_VOCAL_MORPHER_DEFAULT_PHONEMEA_COARSE_TUNING (0)
+
+#define AL_VOCAL_MORPHER_MIN_PHONEMEB            (0)
+#define AL_VOCAL_MORPHER_MAX_PHONEMEB            (29)
+#define AL_VOCAL_MORPHER_DEFAULT_PHONEMEB        (10)
+
+#define AL_VOCAL_MORPHER_MIN_PHONEMEB_COARSE_TUNING (-24)
+#define AL_VOCAL_MORPHER_MAX_PHONEMEB_COARSE_TUNING (24)
+#define AL_VOCAL_MORPHER_DEFAULT_PHONEMEB_COARSE_TUNING (0)
+
+#define AL_VOCAL_MORPHER_PHONEME_A               (0)
+#define AL_VOCAL_MORPHER_PHONEME_E               (1)
+#define AL_VOCAL_MORPHER_PHONEME_I               (2)
+#define AL_VOCAL_MORPHER_PHONEME_O               (3)
+#define AL_VOCAL_MORPHER_PHONEME_U               (4)
+#define AL_VOCAL_MORPHER_PHONEME_AA              (5)
+#define AL_VOCAL_MORPHER_PHONEME_AE              (6)
+#define AL_VOCAL_MORPHER_PHONEME_AH              (7)
+#define AL_VOCAL_MORPHER_PHONEME_AO              (8)
+#define AL_VOCAL_MORPHER_PHONEME_EH              (9)
+#define AL_VOCAL_MORPHER_PHONEME_ER              (10)
+#define AL_VOCAL_MORPHER_PHONEME_IH              (11)
+#define AL_VOCAL_MORPHER_PHONEME_IY              (12)
+#define AL_VOCAL_MORPHER_PHONEME_UH              (13)
+#define AL_VOCAL_MORPHER_PHONEME_UW              (14)
+#define AL_VOCAL_MORPHER_PHONEME_B               (15)
+#define AL_VOCAL_MORPHER_PHONEME_D               (16)
+#define AL_VOCAL_MORPHER_PHONEME_F               (17)
+#define AL_VOCAL_MORPHER_PHONEME_G               (18)
+#define AL_VOCAL_MORPHER_PHONEME_J               (19)
+#define AL_VOCAL_MORPHER_PHONEME_K               (20)
+#define AL_VOCAL_MORPHER_PHONEME_L               (21)
+#define AL_VOCAL_MORPHER_PHONEME_M               (22)
+#define AL_VOCAL_MORPHER_PHONEME_N               (23)
+#define AL_VOCAL_MORPHER_PHONEME_P               (24)
+#define AL_VOCAL_MORPHER_PHONEME_R               (25)
+#define AL_VOCAL_MORPHER_PHONEME_S               (26)
+#define AL_VOCAL_MORPHER_PHONEME_T               (27)
+#define AL_VOCAL_MORPHER_PHONEME_V               (28)
+#define AL_VOCAL_MORPHER_PHONEME_Z               (29)
+
+#define AL_VOCAL_MORPHER_WAVEFORM_SINUSOID       (0)
+#define AL_VOCAL_MORPHER_WAVEFORM_TRIANGLE       (1)
+#define AL_VOCAL_MORPHER_WAVEFORM_SAWTOOTH       (2)
+
+#define AL_VOCAL_MORPHER_MIN_WAVEFORM            (0)
+#define AL_VOCAL_MORPHER_MAX_WAVEFORM            (2)
+#define AL_VOCAL_MORPHER_DEFAULT_WAVEFORM        (0)
+
+#define AL_VOCAL_MORPHER_MIN_RATE                (0.0f)
+#define AL_VOCAL_MORPHER_MAX_RATE                (10.0f)
+#define AL_VOCAL_MORPHER_DEFAULT_RATE            (1.41f)
+
+/* Pitch shifter effect */
+#define AL_PITCH_SHIFTER_MIN_COARSE_TUNE         (-12)
+#define AL_PITCH_SHIFTER_MAX_COARSE_TUNE         (12)
+#define AL_PITCH_SHIFTER_DEFAULT_COARSE_TUNE     (12)
+
+#define AL_PITCH_SHIFTER_MIN_FINE_TUNE           (-50)
+#define AL_PITCH_SHIFTER_MAX_FINE_TUNE           (50)
+#define AL_PITCH_SHIFTER_DEFAULT_FINE_TUNE       (0)
+
+/* Ring modulator effect */
+#define AL_RING_MODULATOR_MIN_FREQUENCY          (0.0f)
+#define AL_RING_MODULATOR_MAX_FREQUENCY          (8000.0f)
+#define AL_RING_MODULATOR_DEFAULT_FREQUENCY      (440.0f)
+
+#define AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF    (0.0f)
+#define AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF    (24000.0f)
+#define AL_RING_MODULATOR_DEFAULT_HIGHPASS_CUTOFF (800.0f)
+
+#define AL_RING_MODULATOR_SINUSOID               (0)
+#define AL_RING_MODULATOR_SAWTOOTH               (1)
+#define AL_RING_MODULATOR_SQUARE                 (2)
+
+#define AL_RING_MODULATOR_MIN_WAVEFORM           (0)
+#define AL_RING_MODULATOR_MAX_WAVEFORM           (2)
+#define AL_RING_MODULATOR_DEFAULT_WAVEFORM       (0)
+
+/* Autowah effect */
+#define AL_AUTOWAH_MIN_ATTACK_TIME               (0.0001f)
+#define AL_AUTOWAH_MAX_ATTACK_TIME               (1.0f)
+#define AL_AUTOWAH_DEFAULT_ATTACK_TIME           (0.06f)
+
+#define AL_AUTOWAH_MIN_RELEASE_TIME              (0.0001f)
+#define AL_AUTOWAH_MAX_RELEASE_TIME              (1.0f)
+#define AL_AUTOWAH_DEFAULT_RELEASE_TIME          (0.06f)
+
+#define AL_AUTOWAH_MIN_RESONANCE                 (2.0f)
+#define AL_AUTOWAH_MAX_RESONANCE                 (1000.0f)
+#define AL_AUTOWAH_DEFAULT_RESONANCE             (1000.0f)
+
+#define AL_AUTOWAH_MIN_PEAK_GAIN                 (0.00003f)
+#define AL_AUTOWAH_MAX_PEAK_GAIN                 (31621.0f)
+#define AL_AUTOWAH_DEFAULT_PEAK_GAIN             (11.22f)
+
+/* Compressor effect */
+#define AL_COMPRESSOR_MIN_ONOFF                  (0)
+#define AL_COMPRESSOR_MAX_ONOFF                  (1)
+#define AL_COMPRESSOR_DEFAULT_ONOFF              (1)
+
+/* Equalizer effect */
+#define AL_EQUALIZER_MIN_LOW_GAIN                (0.126f)
+#define AL_EQUALIZER_MAX_LOW_GAIN                (7.943f)
+#define AL_EQUALIZER_DEFAULT_LOW_GAIN            (1.0f)
+
+#define AL_EQUALIZER_MIN_LOW_CUTOFF              (50.0f)
+#define AL_EQUALIZER_MAX_LOW_CUTOFF              (800.0f)
+#define AL_EQUALIZER_DEFAULT_LOW_CUTOFF          (200.0f)
+
+#define AL_EQUALIZER_MIN_MID1_GAIN               (0.126f)
+#define AL_EQUALIZER_MAX_MID1_GAIN               (7.943f)
+#define AL_EQUALIZER_DEFAULT_MID1_GAIN           (1.0f)
+
+#define AL_EQUALIZER_MIN_MID1_CENTER             (200.0f)
+#define AL_EQUALIZER_MAX_MID1_CENTER             (3000.0f)
+#define AL_EQUALIZER_DEFAULT_MID1_CENTER         (500.0f)
+
+#define AL_EQUALIZER_MIN_MID1_WIDTH              (0.01f)
+#define AL_EQUALIZER_MAX_MID1_WIDTH              (1.0f)
+#define AL_EQUALIZER_DEFAULT_MID1_WIDTH          (1.0f)
+
+#define AL_EQUALIZER_MIN_MID2_GAIN               (0.126f)
+#define AL_EQUALIZER_MAX_MID2_GAIN               (7.943f)
+#define AL_EQUALIZER_DEFAULT_MID2_GAIN           (1.0f)
+
+#define AL_EQUALIZER_MIN_MID2_CENTER             (1000.0f)
+#define AL_EQUALIZER_MAX_MID2_CENTER             (8000.0f)
+#define AL_EQUALIZER_DEFAULT_MID2_CENTER         (3000.0f)
+
+#define AL_EQUALIZER_MIN_MID2_WIDTH              (0.01f)
+#define AL_EQUALIZER_MAX_MID2_WIDTH              (1.0f)
+#define AL_EQUALIZER_DEFAULT_MID2_WIDTH          (1.0f)
+
+#define AL_EQUALIZER_MIN_HIGH_GAIN               (0.126f)
+#define AL_EQUALIZER_MAX_HIGH_GAIN               (7.943f)
+#define AL_EQUALIZER_DEFAULT_HIGH_GAIN           (1.0f)
+
+#define AL_EQUALIZER_MIN_HIGH_CUTOFF             (4000.0f)
+#define AL_EQUALIZER_MAX_HIGH_CUTOFF             (16000.0f)
+#define AL_EQUALIZER_DEFAULT_HIGH_CUTOFF         (6000.0f)
+
+
+/* Source parameter value ranges and defaults. */
+#define AL_MIN_AIR_ABSORPTION_FACTOR             (0.0f)
+#define AL_MAX_AIR_ABSORPTION_FACTOR             (10.0f)
+#define AL_DEFAULT_AIR_ABSORPTION_FACTOR         (0.0f)
+
+#define AL_MIN_ROOM_ROLLOFF_FACTOR               (0.0f)
+#define AL_MAX_ROOM_ROLLOFF_FACTOR               (10.0f)
+#define AL_DEFAULT_ROOM_ROLLOFF_FACTOR           (0.0f)
+
+#define AL_MIN_CONE_OUTER_GAINHF                 (0.0f)
+#define AL_MAX_CONE_OUTER_GAINHF                 (1.0f)
+#define AL_DEFAULT_CONE_OUTER_GAINHF             (1.0f)
+
+#define AL_MIN_DIRECT_FILTER_GAINHF_AUTO         AL_FALSE
+#define AL_MAX_DIRECT_FILTER_GAINHF_AUTO         AL_TRUE
+#define AL_DEFAULT_DIRECT_FILTER_GAINHF_AUTO     AL_TRUE
+
+#define AL_MIN_AUXILIARY_SEND_FILTER_GAIN_AUTO   AL_FALSE
+#define AL_MAX_AUXILIARY_SEND_FILTER_GAIN_AUTO   AL_TRUE
+#define AL_DEFAULT_AUXILIARY_SEND_FILTER_GAIN_AUTO AL_TRUE
+
+#define AL_MIN_AUXILIARY_SEND_FILTER_GAINHF_AUTO AL_FALSE
+#define AL_MAX_AUXILIARY_SEND_FILTER_GAINHF_AUTO AL_TRUE
+#define AL_DEFAULT_AUXILIARY_SEND_FILTER_GAINHF_AUTO AL_TRUE
+
+
+/* Listener parameter value ranges and defaults. */
+#define AL_MIN_METERS_PER_UNIT                   FLT_MIN
+#define AL_MAX_METERS_PER_UNIT                   FLT_MAX
+#define AL_DEFAULT_METERS_PER_UNIT               (1.0f)
+
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#endif /* AL_EFX_H */

OpenAL/libs/Win64/OpenAL32.def

@@ -0,0 +1,187 @@
+EXPORTS
+    alAuxiliaryEffectSlotf
+    alAuxiliaryEffectSlotfv
+    alAuxiliaryEffectSloti
+    alAuxiliaryEffectSlotiv
+    alBuffer3f
+    alBuffer3i
+    alBufferData
+    alBufferSamplesSOFT
+    alBufferSubDataSOFT
+    alBufferSubSamplesSOFT
+    alBufferf
+    alBufferfv
+    alBufferi
+    alBufferiv
+    alDeferUpdatesSOFT
+    alDeleteAuxiliaryEffectSlots
+    alDeleteBuffers
+    alDeleteEffects
+    alDeleteFilters
+    alDeleteFontsoundsSOFT
+    alDeletePresetsSOFT
+    alDeleteSoundfontsSOFT
+    alDeleteSources
+    alDisable
+    alDistanceModel
+    alDopplerFactor
+    alDopplerVelocity
+    alEffectf
+    alEffectfv
+    alEffecti
+    alEffectiv
+    alEnable
+    alFilterf
+    alFilterfv
+    alFilteri
+    alFilteriv
+    alFontsound2iSOFT
+    alFontsoundModulatoriSOFT
+    alFontsoundiSOFT
+    alFontsoundivSOFT
+    alGenAuxiliaryEffectSlots
+    alGenBuffers
+    alGenEffects
+    alGenFilters
+    alGenFontsoundsSOFT
+    alGenPresetsSOFT
+    alGenSoundfontsSOFT
+    alGenSources
+    alGetAuxiliaryEffectSlotf
+    alGetAuxiliaryEffectSlotfv
+    alGetAuxiliaryEffectSloti
+    alGetAuxiliaryEffectSlotiv
+    alGetBoolean
+    alGetBooleanv
+    alGetBuffer3f
+    alGetBuffer3i
+    alGetBufferSamplesSOFT
+    alGetBufferf
+    alGetBufferfv
+    alGetBufferi
+    alGetBufferiv
+    alGetDouble
+    alGetDoublev
+    alGetEffectf
+    alGetEffectfv
+    alGetEffecti
+    alGetEffectiv
+    alGetEnumValue
+    alGetError
+    alGetFilterf
+    alGetFilterfv
+    alGetFilteri
+    alGetFilteriv
+    alGetFloat
+    alGetFloatv
+    alGetFontsoundModulatorivSOFT
+    alGetFontsoundivSOFT
+    alGetInteger
+    alGetInteger64SOFT
+    alGetInteger64vSOFT
+    alGetIntegerv
+    alGetListener3f
+    alGetListener3i
+    alGetListenerf
+    alGetListenerfv
+    alGetListeneri
+    alGetListeneriv
+    alGetPresetivSOFT
+    alGetProcAddress
+    alGetSoundfontivSOFT
+    alGetSource3dSOFT
+    alGetSource3f
+    alGetSource3i
+    alGetSource3i64SOFT
+    alGetSourcedSOFT
+    alGetSourcedvSOFT
+    alGetSourcef
+    alGetSourcefv
+    alGetSourcei
+    alGetSourcei64SOFT
+    alGetSourcei64vSOFT
+    alGetSourceiv
+    alGetString
+    alIsAuxiliaryEffectSlot
+    alIsBuffer
+    alIsBufferFormatSupportedSOFT
+    alIsEffect
+    alIsEnabled
+    alIsExtensionPresent
+    alIsFilter
+    alIsFontsoundSOFT
+    alIsPresetSOFT
+    alIsSoundfontSOFT
+    alIsSource
+    alListener3f
+    alListener3i
+    alListenerf
+    alListenerfv
+    alListeneri
+    alListeneriv
+    alLoadSoundfontSOFT
+    alMidiEventSOFT
+    alMidiGainSOFT
+    alMidiPauseSOFT
+    alMidiPlaySOFT
+    alMidiResetSOFT
+    alMidiSoundfontSOFT
+    alMidiSoundfontvSOFT
+    alMidiStopSOFT
+    alMidiSysExSOFT
+    alPresetFontsoundsSOFT
+    alPresetiSOFT
+    alPresetivSOFT
+    alProcessUpdatesSOFT
+    alSoundfontPresetsSOFT
+    alSource3dSOFT
+    alSource3f
+    alSource3i
+    alSource3i64SOFT
+    alSourcePause
+    alSourcePausev
+    alSourcePlay
+    alSourcePlayv
+    alSourceQueueBuffers
+    alSourceRewind
+    alSourceRewindv
+    alSourceStop
+    alSourceStopv
+    alSourceUnqueueBuffers
+    alSourcedSOFT
+    alSourcedvSOFT
+    alSourcef
+    alSourcefv
+    alSourcei
+    alSourcei64SOFT
+    alSourcei64vSOFT
+    alSourceiv
+    alSpeedOfSound
+    alcCaptureCloseDevice
+    alcCaptureOpenDevice
+    alcCaptureSamples
+    alcCaptureStart
+    alcCaptureStop
+    alcCloseDevice
+    alcCreateContext
+    alcDestroyContext
+    alcDevicePauseSOFT
+    alcDeviceResumeSOFT
+    alcGetContextsDevice
+    alcGetCurrentContext
+    alcGetEnumValue
+    alcGetError
+    alcGetInteger64vSOFT
+    alcGetIntegerv
+    alcGetProcAddress
+    alcGetString
+    alcGetThreadContext
+    alcIsExtensionPresent
+    alcIsRenderFormatSupportedSOFT
+    alcLoopbackOpenDeviceSOFT
+    alcMakeContextCurrent
+    alcOpenDevice
+    alcProcessContext
+    alcRenderSamplesSOFT
+    alcSetThreadContext
+    alcSuspendContext

README.md

@@ -1,4 +1,47 @@
-rpcs3
+RPCS3
 =====
 
-PS3 emulator/debugger
+[![Build Status](https://travis-ci.org/RPCS3/rpcs3.svg?branch=master)](https://travis-ci.org/RPCS3/rpcs3)
+[![Build status](https://ci.appveyor.com/api/projects/status/411c4clmiohtx7eo/branch/master?svg=true)](https://ci.appveyor.com/project/rpcs3/rpcs3/branch/master)
+[![Coverity Status](https://scan.coverity.com/projects/3960/badge.svg)](https://scan.coverity.com/projects/3960)
+[![Coverage Status](https://coveralls.io/repos/DHrpcs3/rpcs3/badge.svg)](https://coveralls.io/r/DHrpcs3/rpcs3)
+
+An open-source PlayStation 3 emulator/debugger written in C++.
+
+You can find some basic information in the [FAQ](https://github.com/DHrpcs3/rpcs3/wiki/FAQ). For discussion about this emulator and PS3 emulation please visit the [official forums](http://www.emunewz.net/forum/forumdisplay.php?fid=162).
+
+
+### Development
+
+If you want to contribute please take a took at the [Coding Style](https://github.com/DHrpcs3/rpcs3/wiki/Coding-Style), [Roadmap](https://github.com/DHrpcs3/rpcs3/wiki/Roadmap) and [Developer Information](https://github.com/DHrpcs3/rpcs3/wiki/Developer-Information) pages. You should as well contact any of the developers in the forum in order to know about the current situation of the emulator.
+
+
+### Dependencies
+
+__Windows__
+* [Visual Studio 2015](https://www.visualstudio.com/en-us/downloads/download-visual-studio-vs.aspx)
+* [Visual C++ Redistributable Packages for Visual Studio 2015](http://www.microsoft.com/en-us/download/details.aspx?id=48145)
+* [Cmake 3.1.0+](http://www.cmake.org/download/) (add to PATH)
+* [Python 2.7+](https://www.python.org/downloads/) (add to PATH)
+
+__Linux__
+* Debian & Ubuntu: `sudo apt-get install libopenal-dev libwxgtk3.0-dev build-essential libglew-dev`
+* Arch: `sudo pacman -S glew openal wxgtk cmake llvm`
+
+__Mac OSX__
+* Install with Homebrew: `brew install glew wxwidgets` (add `llvm36` to that list if you want to build with ppu jit)
+* Remove '-framework QuickTime' from '_ldflags' in /usr/local/bin/wx-config
+
+
+### Building
+
+To initialize the repository don't forget to execute `git submodule update --init` to pull the wxWidgets source.
+* __Windows__:
+Open the *.SLN* file, and press *Build* > *Rebuild Solution*.
+* __Linux & Mac OSX__:
+If you want to build with LLVM, then LLVM 3.6.2 is required.
+`cd rpcs3 && cmake CMakeLists.txt && make && cd ../` Then run with `cd bin && ./rpcs3`
+If you are on OSX and want to build with llvm don't forget to add `-DLLVM_DIR=/usr/local/opt/llvm36/lib/llvm-3.6/share/llvm/cmake` (or wherever llvm brew was installed) to cmake invocation.
+
+### Support
+* [Donate by PayPal](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=MPJ3S9XQXCE3G)

Utilities/Array.h

@@ -1,501 +0,0 @@
-#pragma once
-
-template<typename T> class Array
-{
-protected:
-	u32 m_count;
-	T* m_array;
-
-public:
-	Array()
-		: m_count(0)
-		, m_array(NULL)
-	{
-	}
-
-	~Array()
-	{
-		Clear();
-	}
-
-	inline bool RemoveAt(const u32 from, const u32 count = 1)
-	{
-		if(!GetCount()) return false;
-		const u32 to = from + count;
-		if(to > GetCount()) return false;
-		
-		for(u32 i=0; i<count; ++i) m_array[from + i].~T();
-		memmove(m_array + from, m_array + to, (m_count-to) * sizeof(T));
-		m_count -= count;
-		
-		return true;
-	}
-	
-	void InsertRoomEnd(const u32 size)
-	{
-		_InsertRoomEnd(size);
-	}
-	
-	bool InsertRoom(const u32 pos, const u32 size)
-	{
-		if(pos >= m_count) return false;
-		
-		_InsertRoomEnd(size);
-		memmove(m_array + pos + size, m_array + pos, sizeof(T) * (m_count - size - pos));
-
-		return true;
-	}
-
-	inline bool Move(const u32 pos, T* data)
-	{
-		if(!InsertRoom(pos, 1)) return false;
-		
-		memcpy(m_array + pos, data, sizeof(T));
-		free(data);
-		
-		return true;
-	}
-
-	inline u32 Move(T* data)
-	{
-		_InsertRoomEnd(1);
-
-		memcpy(m_array + GetCount() - 1, data, sizeof(T));
-		free(data);
-
-		return m_count - 1;
-	}
-
-	inline bool Add(const u32 pos, T*& data)
-	{
-		if(!InsertRoom(pos, 1)) return false;
-		
-		memcpy(m_array + pos, data, sizeof(T));
-		free(data);
-		data = m_array + pos;
-		
-		return true;
-	}
-
-	inline u32 Add(T*& data)
-	{
-		_InsertRoomEnd(1);
-
-		memcpy(m_array + GetCount() - 1, data, sizeof(T));
-		free(data);
-		data = m_array + GetCount() - 1;
-		
-		return m_count - 1;
-	}
-
-	inline bool AddCpy(const u32 pos, const T* data, u32 count = 1)
-	{
-		if(!InsertRoom(pos, count)) return false;
-		
-		for(u32 i=0; i<count; ++i)
-		{
-			new (m_array + pos + i) T(data[i]);
-		}
-
-		return true;
-	}
-
-	inline bool AddCpy(const u32 pos, const T& data)
-	{
-		return AddCpy(pos, &data);
-	}
-
-	inline u32 AddCpy(const T* data, u32 count = 1)
-	{
-		_InsertRoomEnd(count);
-
-		for(u32 i=0; i<count; ++i)
-		{
-			new (m_array + m_count - count + i) T(data[i]);
-		}
-
-		return m_count - count;
-	}
-
-	inline u32 AddCpy(const T& data)
-	{
-		return AddCpy(&data);
-	}
-
-	inline void Clear()
-	{
-		u32 count = m_count;
-		m_count = 0;
-		for(u32 i=0; i<count; ++i) m_array[i].~T();
-		safe_free(m_array);
-	}
-
-	inline void ClearF()
-	{
-		m_count = 0;
-		safe_free(m_array);
-	}
-
-	inline T& Get(u32 num)
-	{
-		//if(num >= GetCount()) return *new T();
-		return m_array[num];
-	}
-
-	virtual u32 GetCount() const { return m_count; }
-
-	virtual void SetCount(const u32 count, bool memzero = true)
-	{
-		if(m_count >= count) return;
-
-		_InsertRoomEnd(count - m_count);
-
-		if(memzero) memset(m_array + m_count - count, 0, sizeof(T) * (m_count - count));
-	}
-
-	void Reserve(const u32 count)
-	{
-		SetCount(GetCount() + count);
-	}
-
-	void AppendFrom(const Array<T>& src)
-	{
-		if(!src.GetCount()) return;
-
-		Reserve(src.GetCount());
-
-		memcpy(m_array, &src[0], GetCount() * sizeof(T));
-	}
-
-	void CopyFrom(const Array<T>& src)
-	{
-		Clear();
-
-		AppendFrom(src);
-	}
-
-	inline T* GetPtr() { return m_array; }
-	inline const T* GetPtr() const { return m_array; }
-
-	T& operator[](u32 num) const { return m_array[num]; }
-	
-	T* operator + (u32 right) const
-	{
-		return m_array + right;
-	}
-
-	T* operator ->()
-	{
-		return m_array;
-	}
-
-protected:	
-	void _InsertRoomEnd(const u32 size)
-	{
-		if(!size) return;
-
-		m_array = m_count ? (T*)realloc(m_array, sizeof(T) * (m_count + size)) : (T*)malloc(sizeof(T) * size);
-		m_count += size;
-	}
-};
-
-class ArrayString : public Array<char>
-{
-public:
-	ArrayString() : Array()
-	{
-	}
-
-	ArrayString(const wxString& value) : Array()
-	{
-		*this = value;
-	}
-
-	ArrayString(const char* value) : Array()
-	{
-		*this = value;
-	}
-
-	virtual u32 GetCount() const
-	{
-		return m_array ? strlen(m_array) : 0;
-	}
-
-	virtual void SetCount(const u32 count, bool memzero = true)
-	{
-		if(m_count && count < m_count - 1)
-		{
-			m_array[count] = '\0';
-		}
-		else
-		{
-			Array::SetCount(count + 1, memzero);
-		}
-	}
-
-	ArrayString& operator = (const char* right)
-	{
-		Clear();
-
-		if(right)
-		{
-			size_t len = strlen(right);
-
-			if(len)
-			{
-				SetCount(len);
-				memcpy(m_array, right, len * sizeof(char));
-				m_array[len] = '\0';
-			}
-		}
-
-		return *this;
-	}
-
-	ArrayString& operator = (const ArrayString& right)
-	{
-		Clear();
-
-		if(size_t len = right.GetCount())
-		{
-			SetCount(len);
-			memcpy(m_array, right.GetPtr(), len * sizeof(char));
-			m_array[len] = '\0';
-		}
-
-		return *this;
-	}
-
-	ArrayString& operator = (const wxString& right)
-	{
-		Clear();
-
-		if(size_t len = right.Len())
-		{
-			SetCount(len);
-			memcpy(m_array, right.c_str(), len * sizeof(char));
-			m_array[len] = '\0';
-		}
-
-		return *this;
-	}
-
-	ArrayString* Clone() const
-	{
-		ArrayString* new_array = new ArrayString();
-		(*new_array) = m_array;
-
-		return new_array;
-	}
-};
-
-template<typename T> struct Stack : public Array<T>
-{
-	Stack() : Array<T>()
-	{
-	}
-
-	~Stack()
-	{
-		Clear();
-	}
-
-	void Push(const T data) { AddCpy(data); }
-
-	T Pop()
-	{
-		const u32 pos = GetCount() - 1;
-
-		const T ret = Get(pos);
-		RemoveAt(pos);
-
-		return ret;
-	}
-};
-
-template<typename T, size_t size> class SizedStack
-{
-	T m_ptr[size];
-	uint m_count;
-
-public:
-	SizedStack()
-	{
-		Clear();
-	}
-
-	~SizedStack()
-	{
-		Clear();
-	}
-
-	void Clear()
-	{
-		m_count = 0;
-	}
-
-	bool Pop(T& dst)
-	{
-		if(!m_count)
-			return false;
-
-		dst = m_ptr[--m_count];
-		return true;
-	}
-
-	bool Push(const T& src)
-	{
-		if(m_count + 1 > size)
-			return false;
-
-		m_ptr[m_count++] = src;
-		return true;
-	}
-
-	size_t GetFreeCount() const
-	{
-		return size - m_count;
-	}
-
-	size_t GetCount() const
-	{
-		return m_count;
-	}
-
-	size_t GetMaxCount() const
-	{
-		return size;
-	}
-};
-
-template<typename T> class ArrayF
-{
-	u32 m_count;
-	T** m_array;
-
-public:
-	ArrayF()
-		: m_count(0)
-		, m_array(NULL)
-	{
-	}
-
-	virtual ~ArrayF()
-	{
-		Clear();
-	}
-
-	inline bool RemoveFAt(const u32 from, const u32 count = 1)
-	{
-		if(from + count > m_count) return false;
-
-		memmove(&m_array[from], &m_array[from+count], (m_count-(from+count)) * sizeof(T**));
-
-		m_count -= count;
-		return true;
-	}
-
-	inline bool RemoveAt(const u32 from, const u32 count = 1)
-	{
-		if(from + count > m_count) return false;
-
-		for(uint i = from; i < from + count; ++i)
-		{
-			free(m_array[i]);
-		}
-
-		return RemoveFAt(from, count);
-	}
-
-	inline u32 Add(T& data)
-	{
-		return Add(&data);
-	}
-
-	inline u32 Add(T* data)
-	{
-		if(!m_array)
-		{
-			m_array = (T**)malloc(sizeof(T*));
-		}
-		else
-		{
-			m_array = (T**)realloc(m_array, sizeof(T*) * (m_count + 1));
-		}
-
-		m_array[m_count] = data;
-		return m_count++;
-	}
-
-	inline void ClearF()
-	{
-		if(m_count == 0) return;
-
-		m_count = 0;
-		m_array = NULL;
-	}
-
-	inline void Clear()
-	{
-		if(m_count == 0) return;
-
-		m_count = 0;
-		safe_free(m_array);
-	}
-
-	inline T& Get(const u64 num)
-	{
-		//if(m_count <= num) *m_array[0]; //TODO
-		return *m_array[num];
-	}
-
-	T** operator + (u32 right) const
-	{
-		return m_array + right;
-	}
-
-	T* operator ->()
-	{
-		return *m_array;
-	}
-
-	inline T** GetPtr()
-	{
-		return m_array;
-	}
-
-	inline u32 GetCount() const { return m_count; }
-	T& operator[](u32 num) const { return *m_array[num]; }
-};
-
-template<typename T> struct ScopedPtr
-{
-private:
-	T* m_ptr;
-
-public:
-	ScopedPtr() : m_ptr(nullptr)
-	{
-	}
-
-	ScopedPtr(T* ptr) : m_ptr(ptr)
-	{
-	}
-
-	~ScopedPtr()
-	{
-		Swap(nullptr);
-	}
-
-	operator T*() { return m_ptr; }
-	operator const T*() const { return m_ptr; }
-
-	T* operator ->() { return m_ptr; }
-	const T* operator ->() const { return m_ptr; }
-
-	void Swap(T* ptr)
-	{
-		delete m_ptr;
-		m_ptr = ptr;
-	}
-};

Utilities/Atomic.h

@@ -0,0 +1,717 @@
+#pragma once
+
+#if defined(__GNUG__)
+
+template<typename T, typename T2> inline std::enable_if_t<IS_INTEGRAL(T), T> sync_val_compare_and_swap(volatile T* dest, T2 comp, T2 exch)
+{
+	return __sync_val_compare_and_swap(dest, comp, exch);
+}
+
+template<typename T, typename T2> inline std::enable_if_t<IS_INTEGRAL(T), bool> sync_bool_compare_and_swap(volatile T* dest, T2 comp, T2 exch)
+{
+	return __sync_bool_compare_and_swap(dest, comp, exch);
+}
+
+template<typename T, typename T2> inline std::enable_if_t<IS_INTEGRAL(T), T> sync_lock_test_and_set(volatile T* dest, T2 value)
+{
+	return __sync_lock_test_and_set(dest, value);
+}
+
+template<typename T, typename T2> inline std::enable_if_t<IS_INTEGRAL(T), T> sync_fetch_and_add(volatile T* dest, T2 value)
+{
+	return __sync_fetch_and_add(dest, value);
+}
+
+template<typename T, typename T2> inline std::enable_if_t<IS_INTEGRAL(T), T> sync_fetch_and_sub(volatile T* dest, T2 value)
+{
+	return __sync_fetch_and_sub(dest, value);
+}
+
+template<typename T, typename T2> inline std::enable_if_t<IS_INTEGRAL(T), T> sync_fetch_and_or(volatile T* dest, T2 value)
+{
+	return __sync_fetch_and_or(dest, value);
+}
+
+template<typename T, typename T2> inline std::enable_if_t<IS_INTEGRAL(T), T> sync_fetch_and_and(volatile T* dest, T2 value)
+{
+	return __sync_fetch_and_and(dest, value);
+}
+
+template<typename T, typename T2> inline std::enable_if_t<IS_INTEGRAL(T), T> sync_fetch_and_xor(volatile T* dest, T2 value)
+{
+	return __sync_fetch_and_xor(dest, value);
+}
+
+#elif defined(_MSC_VER)
+
+// atomic compare and swap functions
+
+inline u8 sync_val_compare_and_swap(volatile u8* dest, u8 comp, u8 exch)
+{
+	return _InterlockedCompareExchange8((volatile char*)dest, exch, comp);
+}
+
+inline u16 sync_val_compare_and_swap(volatile u16* dest, u16 comp, u16 exch)
+{
+	return _InterlockedCompareExchange16((volatile short*)dest, exch, comp);
+}
+
+inline u32 sync_val_compare_and_swap(volatile u32* dest, u32 comp, u32 exch)
+{
+	return _InterlockedCompareExchange((volatile long*)dest, exch, comp);
+}
+
+inline u64 sync_val_compare_and_swap(volatile u64* dest, u64 comp, u64 exch)
+{
+	return _InterlockedCompareExchange64((volatile long long*)dest, exch, comp);
+}
+
+inline u128 sync_val_compare_and_swap(volatile u128* dest, u128 comp, u128 exch)
+{
+	_InterlockedCompareExchange128((volatile long long*)dest, exch.hi, exch.lo, (long long*)&comp);
+	return comp;
+}
+
+inline bool sync_bool_compare_and_swap(volatile u8* dest, u8 comp, u8 exch)
+{
+	return (u8)_InterlockedCompareExchange8((volatile char*)dest, exch, comp) == comp;
+}
+
+inline bool sync_bool_compare_and_swap(volatile u16* dest, u16 comp, u16 exch)
+{
+	return (u16)_InterlockedCompareExchange16((volatile short*)dest, exch, comp) == comp;
+}
+
+inline bool sync_bool_compare_and_swap(volatile u32* dest, u32 comp, u32 exch)
+{
+	return (u32)_InterlockedCompareExchange((volatile long*)dest, exch, comp) == comp;
+}
+
+inline bool sync_bool_compare_and_swap(volatile u64* dest, u64 comp, u64 exch)
+{
+	return (u64)_InterlockedCompareExchange64((volatile long long*)dest, exch, comp) == comp;
+}
+
+inline bool sync_bool_compare_and_swap(volatile u128* dest, u128 comp, u128 exch)
+{
+	return _InterlockedCompareExchange128((volatile long long*)dest, exch.hi, exch.lo, (long long*)&comp) != 0;
+}
+
+// atomic exchange functions
+
+inline u8 sync_lock_test_and_set(volatile u8* dest, u8 value)
+{
+	return _InterlockedExchange8((volatile char*)dest, value);
+}
+
+inline u16 sync_lock_test_and_set(volatile u16* dest, u16 value)
+{
+	return _InterlockedExchange16((volatile short*)dest, value);
+}
+
+inline u32 sync_lock_test_and_set(volatile u32* dest, u32 value)
+{
+	return _InterlockedExchange((volatile long*)dest, value);
+}
+
+inline u64 sync_lock_test_and_set(volatile u64* dest, u64 value)
+{
+	return _InterlockedExchange64((volatile long long*)dest, value);
+}
+
+inline u128 sync_lock_test_and_set(volatile u128* dest, u128 value)
+{
+	while (true)
+	{
+		u128 old;
+		old.lo = dest->lo;
+		old.hi = dest->hi;
+
+		if (sync_bool_compare_and_swap(dest, old, value)) return old;
+	}
+}
+
+// atomic add functions
+
+inline u8 sync_fetch_and_add(volatile u8* dest, u8 value)
+{
+	return _InterlockedExchangeAdd8((volatile char*)dest, value);
+}
+
+inline u16 sync_fetch_and_add(volatile u16* dest, u16 value)
+{
+	return _InterlockedExchangeAdd16((volatile short*)dest, value);
+}
+
+inline u32 sync_fetch_and_add(volatile u32* dest, u32 value)
+{
+	return _InterlockedExchangeAdd((volatile long*)dest, value);
+}
+
+inline u64 sync_fetch_and_add(volatile u64* dest, u64 value)
+{
+	return _InterlockedExchangeAdd64((volatile long long*)dest, value);
+}
+
+inline u128 sync_fetch_and_add(volatile u128* dest, u128 value)
+{
+	while (true)
+	{
+		u128 old;
+		old.lo = dest->lo;
+		old.hi = dest->hi;
+
+		u128 _new;
+		_new.lo = old.lo + value.lo;
+		_new.hi = old.hi + value.hi + (_new.lo < value.lo);
+
+		if (sync_bool_compare_and_swap(dest, old, _new)) return old;
+	}
+}
+
+// atomic sub functions
+
+inline u8 sync_fetch_and_sub(volatile u8* dest, u8 value)
+{
+	return _InterlockedExchangeAdd8((volatile char*)dest, -(char)value);
+}
+
+inline u16 sync_fetch_and_sub(volatile u16* dest, u16 value)
+{
+	return _InterlockedExchangeAdd16((volatile short*)dest, -(short)value);
+}
+
+inline u32 sync_fetch_and_sub(volatile u32* dest, u32 value)
+{
+	return _InterlockedExchangeAdd((volatile long*)dest, -(long)value);
+}
+
+inline u64 sync_fetch_and_sub(volatile u64* dest, u64 value)
+{
+	return _InterlockedExchangeAdd64((volatile long long*)dest, -(long long)value);
+}
+
+inline u128 sync_fetch_and_sub(volatile u128* dest, u128 value)
+{
+	while (true)
+	{
+		u128 old;
+		old.lo = dest->lo;
+		old.hi = dest->hi;
+
+		u128 _new;
+		_new.lo = old.lo - value.lo;
+		_new.hi = old.hi - value.hi - (old.lo < value.lo);
+
+		if (sync_bool_compare_and_swap(dest, old, _new)) return old;
+	}
+}
+
+// atomic `bitwise or` functions
+
+inline u8 sync_fetch_and_or(volatile u8* dest, u8 value)
+{
+	return _InterlockedOr8((volatile char*)dest, value);
+}
+
+inline u16 sync_fetch_and_or(volatile u16* dest, u16 value)
+{
+	return _InterlockedOr16((volatile short*)dest, value);
+}
+
+inline u32 sync_fetch_and_or(volatile u32* dest, u32 value)
+{
+	return _InterlockedOr((volatile long*)dest, value);
+}
+
+inline u64 sync_fetch_and_or(volatile u64* dest, u64 value)
+{
+	return _InterlockedOr64((volatile long long*)dest, value);
+}
+
+inline u128 sync_fetch_and_or(volatile u128* dest, u128 value)
+{
+	while (true)
+	{
+		u128 old;
+		old.lo = dest->lo;
+		old.hi = dest->hi;
+
+		u128 _new;
+		_new.lo = old.lo | value.lo;
+		_new.hi = old.hi | value.hi;
+
+		if (sync_bool_compare_and_swap(dest, old, _new)) return old;
+	}
+}
+
+// atomic `bitwise and` functions
+
+inline u8 sync_fetch_and_and(volatile u8* dest, u8 value)
+{
+	return _InterlockedAnd8((volatile char*)dest, value);
+}
+
+inline u16 sync_fetch_and_and(volatile u16* dest, u16 value)
+{
+	return _InterlockedAnd16((volatile short*)dest, value);
+}
+
+inline u32 sync_fetch_and_and(volatile u32* dest, u32 value)
+{
+	return _InterlockedAnd((volatile long*)dest, value);
+}
+
+inline u64 sync_fetch_and_and(volatile u64* dest, u64 value)
+{
+	return _InterlockedAnd64((volatile long long*)dest, value);
+}
+
+inline u128 sync_fetch_and_and(volatile u128* dest, u128 value)
+{
+	while (true)
+	{
+		u128 old;
+		old.lo = dest->lo;
+		old.hi = dest->hi;
+
+		u128 _new;
+		_new.lo = old.lo & value.lo;
+		_new.hi = old.hi & value.hi;
+
+		if (sync_bool_compare_and_swap(dest, old, _new)) return old;
+	}
+}
+
+// atomic `bitwise xor` functions
+
+inline u8 sync_fetch_and_xor(volatile u8* dest, u8 value)
+{
+	return _InterlockedXor8((volatile char*)dest, value);
+}
+
+inline u16 sync_fetch_and_xor(volatile u16* dest, u16 value)
+{
+	return _InterlockedXor16((volatile short*)dest, value);
+}
+
+inline u32 sync_fetch_and_xor(volatile u32* dest, u32 value)
+{
+	return _InterlockedXor((volatile long*)dest, value);
+}
+
+inline u64 sync_fetch_and_xor(volatile u64* dest, u64 value)
+{
+	return _InterlockedXor64((volatile long long*)dest, value);
+}
+
+inline u128 sync_fetch_and_xor(volatile u128* dest, u128 value)
+{
+	while (true)
+	{
+		u128 old;
+		old.lo = dest->lo;
+		old.hi = dest->hi;
+
+		u128 _new;
+		_new.lo = old.lo ^ value.lo;
+		_new.hi = old.hi ^ value.hi;
+
+		if (sync_bool_compare_and_swap(dest, old, _new)) return old;
+	}
+}
+
+#endif /* _MSC_VER */
+
+template<typename T, std::size_t Size = sizeof(T)> struct atomic_storage
+{
+	static_assert(!Size, "Invalid atomic type");
+};
+
+template<typename T> struct atomic_storage<T, 1>
+{
+	using type = u8;
+};
+
+template<typename T> struct atomic_storage<T, 2>
+{
+	using type = u16;
+};
+
+template<typename T> struct atomic_storage<T, 4>
+{
+	using type = u32;
+};
+
+template<typename T> struct atomic_storage<T, 8>
+{
+	using type = u64;
+};
+
+template<typename T> struct atomic_storage<T, 16>
+{
+	using type = u128;
+};
+
+template<typename T> using atomic_storage_t = typename atomic_storage<T>::type;
+
+// result wrapper to deal with void result type
+template<typename T, typename RT, typename VT> struct atomic_op_result_t
+{
+	RT result;
+
+	template<typename... Args> inline atomic_op_result_t(T func, VT& var, Args&&... args)
+		: result(std::move(func(var, std::forward<Args>(args)...)))
+	{
+	}
+
+	inline RT move()
+	{
+		return std::move(result);
+	}
+};
+
+// void specialization: result is the initial value of the first arg
+template<typename T, typename VT> struct atomic_op_result_t<T, void, VT>
+{
+	VT result;
+
+	template<typename... Args> inline atomic_op_result_t(T func, VT& var, Args&&... args)
+		: result(var)
+	{
+		func(var, std::forward<Args>(args)...);
+	}
+
+	inline VT move()
+	{
+		return std::move(result);
+	}
+};
+
+// member function specialization
+template<typename CT, typename... FArgs, typename RT, typename VT> struct atomic_op_result_t<RT(CT::*)(FArgs...), RT, VT>
+{
+	RT result;
+
+	template<typename... Args> inline atomic_op_result_t(RT(CT::*func)(FArgs...), VT& var, Args&&... args)
+		: result(std::move((var.*func)(std::forward<Args>(args)...)))
+	{
+	}
+
+	inline RT move()
+	{
+		return std::move(result);
+	}
+};
+
+// member function void specialization
+template<typename CT, typename... FArgs, typename VT> struct atomic_op_result_t<void(CT::*)(FArgs...), void, VT>
+{
+	VT result;
+
+	template<typename... Args> inline atomic_op_result_t(void(CT::*func)(FArgs...), VT& var, Args&&... args)
+		: result(var)
+	{
+		(var.*func)(std::forward<Args>(args)...);
+	}
+
+	inline VT move()
+	{
+		return std::move(result);
+	}
+};
+
+template<typename T> class atomic_t
+{
+	using type = std::remove_cv_t<T>;
+	using stype = atomic_storage_t<type>;
+	using storage = atomic_storage<type>;
+
+	static_assert(alignof(type) <= alignof(stype), "atomic_t<> error: unexpected alignment");
+
+	stype m_data;
+
+	template<typename T2> static inline void write_relaxed(volatile T2& data, const T2& value)
+	{
+		data = value;
+	}
+
+	static inline void write_relaxed(volatile u128& data, const u128& value)
+	{
+		sync_lock_test_and_set(&data, value);
+	}
+
+	template<typename T2> static inline T2 read_relaxed(const volatile T2& data)
+	{
+		return data;
+	}
+
+	static inline u128 read_relaxed(const volatile u128& value)
+	{
+		return sync_val_compare_and_swap(const_cast<volatile u128*>(&value), u128{0}, u128{0});
+	}
+
+public:
+	static inline const stype to_subtype(const type& value)
+	{
+		return reinterpret_cast<const stype&>(value);
+	}
+
+	static inline const type from_subtype(const stype value)
+	{
+		return reinterpret_cast<const type&>(value);
+	}
+
+	atomic_t() = default;
+
+	atomic_t(const atomic_t&) = delete;
+
+	atomic_t(atomic_t&&) = delete;
+
+	inline atomic_t(type value)
+		: m_data(to_subtype(value))
+	{
+	}
+
+	atomic_t& operator =(const atomic_t&) = delete;
+
+	atomic_t& operator =(atomic_t&&) = delete;
+
+	inline atomic_t& operator =(type value)
+	{
+		return write_relaxed(m_data, to_subtype(value)), *this;
+	}
+
+	operator type() const volatile
+	{
+		return from_subtype(read_relaxed(m_data));
+	}
+
+	// Unsafe direct access
+	stype* raw_data()
+	{
+		return reinterpret_cast<stype*>(&m_data);
+	}
+
+	// Unsafe direct access
+	type& raw()
+	{
+		return reinterpret_cast<type&>(m_data);
+	}
+
+	// Atomically compare data with cmp, replace with exch if equal, return previous data value anyway
+	inline const type compare_and_swap(const type& cmp, const type& exch) volatile
+	{
+		return from_subtype(sync_val_compare_and_swap(&m_data, to_subtype(cmp), to_subtype(exch)));
+	}
+
+	// Atomically compare data with cmp, replace with exch if equal, return true if data was replaced
+	inline bool compare_and_swap_test(const type& cmp, const type& exch) volatile
+	{
+		return sync_bool_compare_and_swap(&m_data, to_subtype(cmp), to_subtype(exch));
+	}
+
+	// Atomically replace data with exch, return previous data value
+	inline const type exchange(const type& exch) volatile
+	{
+		return from_subtype(sync_lock_test_and_set(&m_data, to_subtype(exch)));
+	}
+
+	// Atomically read data, possibly without memory barrier (not for 128 bit)
+	inline const type load() const volatile
+	{
+		return from_subtype(read_relaxed(m_data));
+	}
+
+	// Atomically write data, possibly without memory barrier (not for 128 bit)
+	inline void store(const type& value) volatile
+	{
+		write_relaxed(m_data, to_subtype(value));
+	}
+
+	// Perform an atomic operation on data (func is either pointer to member function or callable object with a T& first arg);
+	// Returns the result of the callable object call or previous (old) value of the atomic variable if the return type is void
+	template<typename F, typename... Args, typename RT = std::result_of_t<F(T&, Args...)>> auto atomic_op(F func, Args&&... args) volatile -> decltype(atomic_op_result_t<F, RT, T>::result)
+	{
+		while (true)
+		{
+			// Read the old value from memory
+			const stype old = read_relaxed(m_data);
+
+			// Copy the old value
+			stype _new = old;
+
+			// Call atomic op for the local copy of the old value and save the return value of the function
+			atomic_op_result_t<F, RT, T> result(func, reinterpret_cast<type&>(_new), args...);
+
+			// Atomically compare value with `old`, replace with `_new` and return on success
+			if (sync_bool_compare_and_swap(&m_data, old, _new)) return result.move();
+		}
+	}
+
+	// Atomic bitwise OR, returns previous data
+	inline const type _or(const type& right) volatile
+	{
+		return from_subtype(sync_fetch_and_or(&m_data, to_subtype(right)));
+	}
+
+	// Atomic bitwise AND, returns previous data
+	inline const type _and(const type& right) volatile
+	{
+		return from_subtype(sync_fetch_and_and(&m_data, to_subtype(right)));
+	}
+
+	// Atomic bitwise AND NOT (inverts right argument), returns previous data
+	inline const type _and_not(const type& right) volatile
+	{
+		return from_subtype(sync_fetch_and_and(&m_data, ~to_subtype(right)));
+	}
+
+	// Atomic bitwise XOR, returns previous data
+	inline const type _xor(const type& right) volatile
+	{
+		return from_subtype(sync_fetch_and_xor(&m_data, to_subtype(right)));
+	}
+
+	inline const type operator |=(const type& right) volatile
+	{
+		return from_subtype(sync_fetch_and_or(&m_data, to_subtype(right)) | to_subtype(right));
+	}
+
+	inline const type operator &=(const type& right) volatile
+	{
+		return from_subtype(sync_fetch_and_and(&m_data, to_subtype(right)) & to_subtype(right));
+	}
+
+	inline const type operator ^=(const type& right) volatile
+	{
+		return from_subtype(sync_fetch_and_xor(&m_data, to_subtype(right)) ^ to_subtype(right));
+	}
+};
+
+template<typename T> inline std::enable_if_t<IS_INTEGRAL(T), T> operator ++(atomic_t<T>& left)
+{
+	return left.from_subtype(sync_fetch_and_add(left.raw_data(), 1) + 1);
+}
+
+template<typename T> inline std::enable_if_t<IS_INTEGRAL(T), T> operator --(atomic_t<T>& left)
+{
+	return left.from_subtype(sync_fetch_and_sub(left.raw_data(), 1) - 1);
+}
+
+template<typename T> inline std::enable_if_t<IS_INTEGRAL(T), T> operator ++(atomic_t<T>& left, int)
+{
+	return left.from_subtype(sync_fetch_and_add(left.raw_data(), 1));
+}
+
+template<typename T> inline std::enable_if_t<IS_INTEGRAL(T), T> operator --(atomic_t<T>& left, int)
+{
+	return left.from_subtype(sync_fetch_and_sub(left.raw_data(), 1));
+}
+
+template<typename T, typename T2> inline std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<T2, T>::value, T> operator +=(atomic_t<T>& left, const T2& right)
+{
+	return left.from_subtype(sync_fetch_and_add(left.raw_data(), right) + right);
+}
+
+template<typename T, typename T2> inline std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<T2, T>::value, T> operator -=(atomic_t<T>& left, const T2& right)
+{
+	return left.from_subtype(sync_fetch_and_sub(left.raw_data(), right) - right);
+}
+
+template<typename T> inline std::enable_if_t<IS_INTEGRAL(T), nse_t<T>> operator ++(atomic_t<nse_t<T>>& left)
+{
+	return left.from_subtype(sync_fetch_and_add(left.raw_data(), 1) + 1);
+}
+
+template<typename T> inline std::enable_if_t<IS_INTEGRAL(T), nse_t<T>> operator --(atomic_t<nse_t<T>>& left)
+{
+	return left.from_subtype(sync_fetch_and_sub(left.raw_data(), 1) - 1);
+}
+
+template<typename T> inline std::enable_if_t<IS_INTEGRAL(T), nse_t<T>> operator ++(atomic_t<nse_t<T>>& left, int)
+{
+	return left.from_subtype(sync_fetch_and_add(left.raw_data(), 1));
+}
+
+template<typename T> inline std::enable_if_t<IS_INTEGRAL(T), nse_t<T>> operator --(atomic_t<nse_t<T>>& left, int)
+{
+	return left.from_subtype(sync_fetch_and_sub(left.raw_data(), 1));
+}
+
+template<typename T, typename T2> inline std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<T2, T>::value, nse_t<T>> operator +=(atomic_t<nse_t<T>>& left, const T2& right)
+{
+	return left.from_subtype(sync_fetch_and_add(left.raw_data(), right) + right);
+}
+
+template<typename T, typename T2> inline std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<T2, T>::value, nse_t<T>> operator -=(atomic_t<nse_t<T>>& left, const T2& right)
+{
+	return left.from_subtype(sync_fetch_and_sub(left.raw_data(), right) - right);
+}
+
+template<typename T> inline std::enable_if_t<IS_INTEGRAL(T), se_t<T>> operator ++(atomic_t<se_t<T>>& left)
+{
+	return left.atomic_op([](se_t<T>& value) -> se_t<T>
+	{
+		return ++value;
+	});
+}
+
+template<typename T> inline std::enable_if_t<IS_INTEGRAL(T), se_t<T>> operator --(atomic_t<se_t<T>>& left)
+{
+	return left.atomic_op([](se_t<T>& value) -> se_t<T>
+	{
+		return --value;
+	});
+}
+
+template<typename T> inline std::enable_if_t<IS_INTEGRAL(T), se_t<T>> operator ++(atomic_t<se_t<T>>& left, int)
+{
+	return left.atomic_op([](se_t<T>& value) -> se_t<T>
+	{
+		return value++;
+	});
+}
+
+template<typename T> inline std::enable_if_t<IS_INTEGRAL(T), se_t<T>> operator --(atomic_t<se_t<T>>& left, int)
+{
+	return left.atomic_op([](se_t<T>& value) -> se_t<T>
+	{
+		return value--;
+	});
+}
+
+template<typename T, typename T2> inline std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<T2, T>::value, se_t<T>> operator +=(atomic_t<se_t<T>>& left, const T2& right)
+{
+	return left.atomic_op([&](se_t<T>& value) -> se_t<T>
+	{
+		return value += right;
+	});
+}
+
+template<typename T, typename T2> inline std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<T2, T>::value, se_t<T>> operator -=(atomic_t<se_t<T>>& left, const T2& right)
+{
+	return left.atomic_op([&](se_t<T>& value) -> se_t<T>
+	{
+		return value -= right;
+	});
+}
+
+template<typename T> using atomic_be_t = atomic_t<be_t<T>>; // Atomic BE Type (for PS3 virtual memory)
+
+template<typename T> using atomic_le_t = atomic_t<le_t<T>>; // Atomic LE Type (for PSV virtual memory)
+
+// Algorithm for std::atomic; similar to atomic_t::atomic_op()
+template<typename T, typename F, typename... Args, typename RT = std::result_of_t<F(T&, Args...)>> auto atomic_op(std::atomic<T>& var, F func, Args&&... args) -> decltype(atomic_op_result_t<F, RT, T>::result)
+{
+	auto old = var.load();
+
+	while (true)
+	{
+		auto _new = old;
+
+		atomic_op_result_t<F, RT, T> result(func, _new, args...);
+
+		if (var.compare_exchange_strong(old, _new)) return result.move();
+	}
+}

Utilities/AutoPause.cpp

@@ -0,0 +1,123 @@
+#include "stdafx.h"
+#include "rpcs3/Ini.h"
+#include "AutoPause.h"
+#include "Utilities/Log.h"
+#include "Utilities/File.h"
+#include "Emu/System.h"
+
+using namespace Debug;
+
+std::unique_ptr<AutoPause> g_autopause;
+
+AutoPause& AutoPause::getInstance(void)
+{
+	if (!g_autopause)
+	{
+		g_autopause.reset(new AutoPause);
+	}
+
+	return *g_autopause;
+}
+
+//Still use binary format. Default Setting should be "disable all auto pause".
+AutoPause::AutoPause(void)
+{
+	m_pause_function.reserve(16);
+	m_pause_syscall.reserve(16);
+	initialized = false;
+	//Reload(false, false);
+	Reload();
+}
+
+//Notice: I would not allow to write the binary to file in this command.
+AutoPause::~AutoPause(void)
+{
+	initialized = false;
+	m_pause_function.clear();
+	m_pause_syscall.clear();
+	m_pause_function_enable = false;
+	m_pause_syscall_enable = false;
+}
+
+//Load Auto Pause Configuration from file "pause.bin"
+//This would be able to create in a GUI window.
+void AutoPause::Reload(void)
+{
+	if (fs::is_file("pause.bin"))
+	{
+		m_pause_function.clear();
+		m_pause_function.reserve(16);
+		m_pause_syscall.clear();
+		m_pause_syscall.reserve(16);
+
+		fs::file list("pause.bin");
+		//System calls ID and Function calls ID are all u32 iirc.
+		u32 num;
+		size_t fmax = list.size();
+		size_t fcur = 0;
+		list.seek(0);
+		while (fcur <= fmax - sizeof(u32))
+		{
+			list.read(&num, sizeof(u32));
+			fcur += sizeof(u32);
+			if (num == 0xFFFFFFFF) break;
+			
+			if (num < 1024)
+			{
+				//Less than 1024 - be regarded as a system call.
+				//emplace_back may not cause reductant move/copy operation.
+				m_pause_syscall.emplace_back(num);
+				LOG_WARNING(HLE, "Auto Pause: Find System Call ID 0x%x", num);
+			}
+			else
+			{
+				m_pause_function.emplace_back(num);
+				LOG_WARNING(HLE, "Auto Pause: Find Function Call ID 0x%x", num);
+			}
+		}
+	}
+
+	m_pause_syscall_enable = Ini.DBGAutoPauseSystemCall.GetValue();
+	m_pause_function_enable = Ini.DBGAutoPauseFunctionCall.GetValue();
+	initialized = true;
+}
+
+void AutoPause::TryPause(u32 code)
+{
+	if (code < 1024)
+	{
+		//Would first check Enable setting. Then the list length.
+		if ((!m_pause_syscall_enable)
+			|| (m_pause_syscall.size() <= 0))
+		{
+			return;
+		}
+
+		for (u32 i = 0; i < m_pause_syscall.size(); ++i)
+		{
+			if (code == m_pause_syscall[i])
+			{
+				Emu.Pause();
+				LOG_ERROR(HLE, "Auto Pause Triggered: System call 0x%x", code); // Used Error
+			}
+		}
+	}
+	else
+	{
+		//Well similiar.. Seperate the list caused by possible setting difference.
+		if ((!m_pause_function_enable)
+			|| (m_pause_function.size() <= 0))
+		{
+			return;
+		}
+
+		for (u32 i = 0; i < m_pause_function.size(); ++i)
+		{
+			if (code == m_pause_function[i])
+			{
+				Emu.Pause();
+				LOG_ERROR(HLE, "Auto Pause Triggered: Function call 0x%x", code); // Used Error
+			}
+		}
+	}
+}

Utilities/AutoPause.h

@@ -0,0 +1,24 @@
+#pragma once
+
+//Regarded as a Debugger Enchantment
+namespace Debug {
+	//To store the pause function/call id, and let those pause there.
+	//Would be with a GUI to configure those.
+	struct AutoPause
+	{
+		std::vector<u32> m_pause_syscall;
+		std::vector<u32> m_pause_function;
+		bool initialized;
+		bool m_pause_syscall_enable;
+		bool m_pause_function_enable;
+
+		AutoPause();
+		~AutoPause();
+	public:
+		static AutoPause& getInstance(void);
+
+		void Reload(void);
+
+		void TryPause(u32 code);
+	};
+}

Utilities/BEType.h

@@ -0,0 +1,943 @@
+#pragma once
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#else
+#include <x86intrin.h>
+#endif
+
+#define IS_LE_MACHINE // only draft
+
+template<typename T, std::size_t N, std::size_t M> class masked_array_t // array type accessed as (index ^ M)
+{
+	T m_data[N];
+
+public:
+	T& operator [](std::size_t index)
+	{
+		return m_data[index ^ M];
+	}
+
+	const T& operator [](std::size_t index) const
+	{
+		return m_data[index ^ M];
+	}
+
+	T& at(std::size_t index)
+	{
+		return (index ^ M) < N ? m_data[index ^ M] : throw std::out_of_range("Masked array");
+	}
+
+	const T& at(std::size_t index) const
+	{
+		return (index ^ M) < N ? m_data[index ^ M] : throw std::out_of_range("Masked array");
+	}
+};
+
+union v128
+{
+#ifdef IS_LE_MACHINE
+	template<typename T, std::size_t N = 16 / sizeof(T)> using normal_array_t = masked_array_t<T, N, 0>;
+	template<typename T, std::size_t N = 16 / sizeof(T)> using reversed_array_t = masked_array_t<T, N, N - 1>;
+#else
+	template<typename T, std::size_t N = 16 / sizeof(T)> using normal_array_t = masked_array_t<T, N, N - 1>;
+	template<typename T, std::size_t N = 16 / sizeof(T)> using reversed_array_t = masked_array_t<T, N, 0>;
+#endif
+
+	normal_array_t<u64>   _u64;
+	normal_array_t<s64>   _s64;
+	reversed_array_t<u64> u64r;
+	reversed_array_t<s64> s64r;
+
+	normal_array_t<u32>   _u32;
+	normal_array_t<s32>   _s32;
+	reversed_array_t<u32> u32r;
+	reversed_array_t<s32> s32r;
+
+	normal_array_t<u16>   _u16;
+	normal_array_t<s16>   _s16;
+	reversed_array_t<u16> u16r;
+	reversed_array_t<s16> s16r;
+
+	normal_array_t<u8>    _u8;
+	normal_array_t<s8>    _s8;
+	reversed_array_t<u8>  u8r;
+	reversed_array_t<s8>  s8r;
+
+	normal_array_t<f32>   _f;
+	normal_array_t<f64>   _d;
+	reversed_array_t<f32> fr;
+	reversed_array_t<f64> dr;
+
+	__m128 vf;
+	__m128i vi;
+	__m128d vd;
+
+	class bit_array_128
+	{
+		u64 m_data[2];
+
+	public:
+		class bit_element
+		{
+			u64& data;
+			const u64 mask;
+
+		public:
+			bit_element(u64& data, const u64 mask)
+				: data(data)
+				, mask(mask)
+			{
+			}
+
+			inline operator bool() const
+			{
+				return (data & mask) != 0;
+			}
+
+			inline bit_element& operator =(const bool right)
+			{
+				if (right)
+				{
+					data |= mask;
+				}
+				else
+				{
+					data &= ~mask;
+				}
+				return *this;
+			}
+
+			inline bit_element& operator =(const bit_element& right)
+			{
+				if (right)
+				{
+					data |= mask;
+				}
+				else
+				{
+					data &= ~mask;
+				}
+				return *this;
+			}
+		};
+
+		// Index 0 returns the MSB and index 127 returns the LSB
+		bit_element operator [](u32 index)
+		{
+#ifdef IS_LE_MACHINE
+			return bit_element(m_data[1 - (index >> 6)], 0x8000000000000000ull >> (index & 0x3F));
+#else
+			return bit_element(m_data[index >> 6], 0x8000000000000000ull >> (index & 0x3F));
+#endif
+		}
+
+		// Index 0 returns the MSB and index 127 returns the LSB
+		bool operator [](u32 index) const
+		{
+#ifdef IS_LE_MACHINE
+			return (m_data[1 - (index >> 6)] & (0x8000000000000000ull >> (index & 0x3F))) != 0;
+#else
+			return (m_data[index >> 6] & (0x8000000000000000ull >> (index & 0x3F))) != 0;
+#endif
+		}
+
+		bit_element at(u32 index)
+		{
+			if (index >= 128) throw std::out_of_range("Bit element");
+
+			return operator[](index);
+		}
+
+		bool at(u32 index) const
+		{
+			if (index >= 128) throw std::out_of_range("Bit element");
+
+			return operator[](index);
+		}
+	}
+	_bit;
+
+	static v128 from64(u64 _0, u64 _1 = 0)
+	{
+		v128 ret;
+		ret._u64[0] = _0;
+		ret._u64[1] = _1;
+		return ret;
+	}
+
+	static v128 from64r(u64 _1, u64 _0 = 0)
+	{
+		return from64(_0, _1);
+	}
+
+	static v128 from32(u32 _0, u32 _1 = 0, u32 _2 = 0, u32 _3 = 0)
+	{
+		v128 ret;
+		ret._u32[0] = _0;
+		ret._u32[1] = _1;
+		ret._u32[2] = _2;
+		ret._u32[3] = _3;
+		return ret;
+	}
+
+	static v128 from32r(u32 _3, u32 _2 = 0, u32 _1 = 0, u32 _0 = 0)
+	{
+		return from32(_0, _1, _2, _3);
+	}
+
+	static v128 from32p(u32 value)
+	{
+		v128 ret;
+		ret.vi = _mm_set1_epi32(static_cast<s32>(value));
+		return ret;
+	}
+
+	static v128 from16p(u16 value)
+	{
+		v128 ret;
+		ret.vi = _mm_set1_epi16(static_cast<s16>(value));
+		return ret;
+	}
+
+	static v128 from8p(u8 value)
+	{
+		v128 ret;
+		ret.vi = _mm_set1_epi8(static_cast<s8>(value));
+		return ret;
+	}
+
+	static v128 fromBit(u32 bit)
+	{
+		v128 ret = {};
+		ret._bit[bit] = true;
+		return ret;
+	}
+
+	static v128 fromV(__m128i value)
+	{
+		v128 ret;
+		ret.vi = value;
+		return ret;
+	}
+
+	static v128 fromF(__m128 value)
+	{
+		v128 ret;
+		ret.vf = value;
+		return ret;
+	}
+
+	static v128 fromD(__m128d value)
+	{
+		v128 ret;
+		ret.vd = value;
+		return ret;
+	}
+
+	static inline v128 add8(const v128& left, const v128& right)
+	{
+		return fromV(_mm_add_epi8(left.vi, right.vi));
+	}
+
+	static inline v128 add16(const v128& left, const v128& right)
+	{
+		return fromV(_mm_add_epi16(left.vi, right.vi));
+	}
+
+	static inline v128 add32(const v128& left, const v128& right)
+	{
+		return fromV(_mm_add_epi32(left.vi, right.vi));
+	}
+
+	static inline v128 addfs(const v128& left, const v128& right)
+	{
+		return fromF(_mm_add_ps(left.vf, right.vf));
+	}
+
+	static inline v128 addfd(const v128& left, const v128& right)
+	{
+		return fromD(_mm_add_pd(left.vd, right.vd));
+	}
+
+	static inline v128 sub8(const v128& left, const v128& right)
+	{
+		return fromV(_mm_sub_epi8(left.vi, right.vi));
+	}
+
+	static inline v128 sub16(const v128& left, const v128& right)
+	{
+		return fromV(_mm_sub_epi16(left.vi, right.vi));
+	}
+
+	static inline v128 sub32(const v128& left, const v128& right)
+	{
+		return fromV(_mm_sub_epi32(left.vi, right.vi));
+	}
+
+	static inline v128 subfs(const v128& left, const v128& right)
+	{
+		return fromF(_mm_sub_ps(left.vf, right.vf));
+	}
+
+	static inline v128 subfd(const v128& left, const v128& right)
+	{
+		return fromD(_mm_sub_pd(left.vd, right.vd));
+	}
+
+	static inline v128 maxu8(const v128& left, const v128& right)
+	{
+		return fromV(_mm_max_epu8(left.vi, right.vi));
+	}
+
+	static inline v128 minu8(const v128& left, const v128& right)
+	{
+		return fromV(_mm_min_epu8(left.vi, right.vi));
+	}
+
+	static inline v128 eq8(const v128& left, const v128& right)
+	{
+		return fromV(_mm_cmpeq_epi8(left.vi, right.vi));
+	}
+
+	static inline v128 eq16(const v128& left, const v128& right)
+	{
+		return fromV(_mm_cmpeq_epi16(left.vi, right.vi));
+	}
+
+	static inline v128 eq32(const v128& left, const v128& right)
+	{
+		return fromV(_mm_cmpeq_epi32(left.vi, right.vi));
+	}
+
+	bool operator ==(const v128& right) const
+	{
+		return _u64[0] == right._u64[0] && _u64[1] == right._u64[1];
+	}
+
+	bool operator !=(const v128& right) const
+	{
+		return _u64[0] != right._u64[0] || _u64[1] != right._u64[1];
+	}
+
+	inline bool is_any_1() const // check if any bit is 1
+	{
+		return _u64[0] || _u64[1];
+	}
+
+	inline bool is_any_0() const // check if any bit is 0
+	{
+		return ~_u64[0] || ~_u64[1];
+	}
+
+	// result = (~left) & (right)
+	static inline v128 andnot(const v128& left, const v128& right)
+	{
+		return fromV(_mm_andnot_si128(left.vi, right.vi));
+	}
+
+	void clear()
+	{
+		_u64[0] = 0;
+		_u64[1] = 0;
+	}
+
+	std::string to_hex() const;
+
+	std::string to_xyzw() const;
+
+	static inline v128 byteswap(const v128 val)
+	{
+		return fromV(_mm_shuffle_epi8(val.vi, _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)));
+	}
+};
+
+CHECK_SIZE_ALIGN(v128, 16, 16);
+
+inline v128 operator |(const v128& left, const v128& right)
+{
+	return v128::fromV(_mm_or_si128(left.vi, right.vi));
+}
+
+inline v128 operator &(const v128& left, const v128& right)
+{
+	return v128::fromV(_mm_and_si128(left.vi, right.vi));
+}
+
+inline v128 operator ^(const v128& left, const v128& right)
+{
+	return v128::fromV(_mm_xor_si128(left.vi, right.vi));
+}
+
+inline v128 operator ~(const v128& other)
+{
+	return v128::from64(~other._u64[0], ~other._u64[1]);
+}
+
+template<typename T, std::size_t Size = sizeof(T)> struct se_storage
+{
+	static_assert(!Size, "Bad se_storage<> type");
+};
+
+template<typename T> struct se_storage<T, 2>
+{
+	using type = u16;
+
+	[[deprecated]] static constexpr u16 swap(u16 src) // for reference
+	{
+		return (src >> 8) | (src << 8);
+	}
+
+	static inline u16 to(const T& src)
+	{
+		return _byteswap_ushort(reinterpret_cast<const u16&>(src));
+	}
+
+	static inline T from(u16 src)
+	{
+		const u16 result = _byteswap_ushort(src);
+		return reinterpret_cast<const T&>(result);
+	}
+};
+
+template<typename T> struct se_storage<T, 4>
+{
+	using type = u32;
+
+	[[deprecated]] static constexpr u32 swap(u32 src) // for reference
+	{
+		return (src >> 24) | (src << 24) | ((src >> 8) & 0x0000ff00) | ((src << 8) & 0x00ff0000);
+	}
+
+	static inline u32 to(const T& src)
+	{
+		return _byteswap_ulong(reinterpret_cast<const u32&>(src));
+	}
+
+	static inline T from(u32 src)
+	{
+		const u32 result = _byteswap_ulong(src);
+		return reinterpret_cast<const T&>(result);
+	}
+};
+
+template<typename T> struct se_storage<T, 8>
+{
+	using type = u64;
+
+	[[deprecated]] static constexpr u64 swap(u64 src) // for reference
+	{
+		return (src >> 56) | (src << 56) |
+			((src >> 40) & 0x000000000000ff00) |
+			((src >> 24) & 0x0000000000ff0000) |
+			((src >> 8)  & 0x00000000ff000000) |
+			((src << 8)  & 0x000000ff00000000) |
+			((src << 24) & 0x0000ff0000000000) |
+			((src << 40) & 0x00ff000000000000);
+	}
+
+	static inline u64 to(const T& src)
+	{
+		return _byteswap_uint64(reinterpret_cast<const u64&>(src));
+	}
+
+	static inline T from(u64 src)
+	{
+		const u64 result = _byteswap_uint64(src);
+		return reinterpret_cast<const T&>(result);
+	}
+};
+
+template<typename T> struct se_storage<T, 16>
+{
+	using type = v128;
+
+	static inline v128 to(const T& src)
+	{
+		return v128::byteswap(reinterpret_cast<const v128&>(src));
+	}
+
+	static inline T from(const v128& src)
+	{
+		const v128 result = v128::byteswap(src);
+		return reinterpret_cast<const T&>(result);
+	}
+};
+
+template<typename T> using se_storage_t = typename se_storage<T>::type;
+
+template<typename T1, typename T2> struct se_convert
+{
+	using type_from = std::remove_cv_t<T1>;
+	using type_to = std::remove_cv_t<T2>;
+	using stype_from = se_storage_t<std::remove_cv_t<T1>>;
+	using stype_to = se_storage_t<std::remove_cv_t<T2>>;
+	using storage_from = se_storage<std::remove_cv_t<T1>>;
+	using storage_to = se_storage<std::remove_cv_t<T2>>;
+
+	static inline std::enable_if_t<std::is_same<type_from, type_to>::value, stype_to> convert(const stype_from& data)
+	{
+		return data;
+	}
+
+	static inline stype_to convert(const stype_from& data, ...)
+	{
+		return storage_to::to(storage_from::from(data));
+	}
+};
+
+static struct se_raw_tag_t {} const se_raw{};
+
+template<typename T, bool Se = true> class se_t;
+
+// se_t with switched endianness
+template<typename T> class se_t<T, true>
+{
+	using type = std::remove_cv_t<T>;
+	using stype = se_storage_t<type>;
+	using storage = se_storage<type>;
+
+	stype m_data;
+
+	static_assert(!std::is_union<type>::value && !std::is_class<type>::value || std::is_same<type, v128>::value || std::is_same<type, u128>::value, "se_t<> error: invalid type (struct or union)");
+	static_assert(!std::is_pointer<type>::value, "se_t<> error: invalid type (pointer)");
+	static_assert(!std::is_reference<type>::value, "se_t<> error: invalid type (reference)");
+	static_assert(!std::is_array<type>::value, "se_t<> error: invalid type (array)");
+	static_assert(!std::is_enum<type>::value, "se_t<> error: invalid type (enumeration), use integral type instead");
+	static_assert(alignof(type) == alignof(stype), "se_t<> error: unexpected alignment");
+
+	template<typename T2, bool = std::is_integral<T2>::value> struct bool_converter
+	{
+		static inline bool to_bool(const se_t<T2>& value)
+		{
+			return static_cast<bool>(value.value());
+		}
+	};
+
+	template<typename T2> struct bool_converter<T2, true>
+	{
+		static inline bool to_bool(const se_t<T2>& value)
+		{
+			return value.m_data != 0;
+		}
+	};
+
+public:
+	se_t() = default;
+
+	se_t(const se_t& right) = default;
+
+	inline se_t(type value)
+		: m_data(storage::to(value))
+	{
+	}
+	
+	// construct directly from raw data (don't use)
+	inline se_t(const stype& raw_value, const se_raw_tag_t&)
+		: m_data(raw_value)
+	{
+	}
+
+	inline type value() const
+	{
+		return storage::from(m_data);
+	}
+
+	// access underlying raw data (don't use)
+	inline const stype& raw_data() const noexcept
+	{
+		return m_data;
+	}
+	
+	se_t& operator =(const se_t&) = default;
+
+	inline se_t& operator =(type value)
+	{
+		return m_data = storage::to(value), *this;
+	}
+
+	inline operator type() const
+	{
+		return storage::from(m_data);
+	}
+
+	// optimization
+	explicit inline operator bool() const
+	{
+		return bool_converter<type>::to_bool(*this);
+	}
+
+	// optimization
+	template<typename T2> inline std::enable_if_t<IS_BINARY_COMPARABLE(T, T2), se_t&> operator &=(const se_t<T2>& right)
+	{
+		return m_data &= right.raw_data(), *this;
+	}
+
+	// optimization
+	template<typename CT> inline std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<CT, T>::value, se_t&> operator &=(CT right)
+	{
+		return m_data &= storage::to(right), *this;
+	}
+
+	// optimization
+	template<typename T2> inline std::enable_if_t<IS_BINARY_COMPARABLE(T, T2), se_t&> operator |=(const se_t<T2>& right)
+	{
+		return m_data |= right.raw_data(), *this;
+	}
+
+	// optimization
+	template<typename CT> inline std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<CT, T>::value, se_t&> operator |=(CT right)
+	{
+		return m_data |= storage::to(right), *this;
+	}
+
+	// optimization
+	template<typename T2> inline std::enable_if_t<IS_BINARY_COMPARABLE(T, T2), se_t&> operator ^=(const se_t<T2>& right)
+	{
+		return m_data ^= right.raw_data(), *this;
+	}
+
+	// optimization
+	template<typename CT> inline std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<CT, T>::value, se_t&> operator ^=(CT right)
+	{
+		return m_data ^= storage::to(right), *this;
+	}
+};
+
+// se_t with native endianness
+template<typename T> class se_t<T, false>
+{
+	using type = std::remove_cv_t<T>;
+
+	type m_data;
+
+	static_assert(!std::is_union<type>::value && !std::is_class<type>::value || std::is_same<type, v128>::value || std::is_same<type, u128>::value, "se_t<> error: invalid type (struct or union)");
+	static_assert(!std::is_pointer<type>::value, "se_t<> error: invalid type (pointer)");
+	static_assert(!std::is_reference<type>::value, "se_t<> error: invalid type (reference)");
+	static_assert(!std::is_array<type>::value, "se_t<> error: invalid type (array)");
+	static_assert(!std::is_enum<type>::value, "se_t<> error: invalid type (enumeration), use integral type instead");
+
+public:
+	se_t() = default;
+
+	se_t(const se_t&) = default;
+
+	inline se_t(type value)
+		: m_data(value)
+	{
+	}
+
+	inline type value() const
+	{
+		return m_data;
+	}
+
+	se_t& operator =(const se_t& value) = default;
+
+	inline se_t& operator =(type value)
+	{
+		return m_data = value, *this;
+	}
+
+	inline operator type() const
+	{
+		return m_data;
+	}
+
+	template<typename CT> inline std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<CT, T>::value, se_t&> operator &=(const CT& right)
+	{
+		return m_data &= right, *this;
+	}
+
+	template<typename CT> inline std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<CT, T>::value, se_t&> operator |=(const CT& right)
+	{
+		return m_data |= right, *this;
+	}
+
+	template<typename CT> inline std::enable_if_t<IS_INTEGRAL(T) && std::is_convertible<CT, T>::value, se_t&> operator ^=(const CT& right)
+	{
+		return m_data ^= right, *this;
+	}
+};
+
+// se_t with native endianness (alias)
+template<typename T> using nse_t = se_t<T, false>;
+
+template<typename T, bool Se, typename T1> inline se_t<T, Se>& operator +=(se_t<T, Se>& left, const T1& right)
+{
+	auto value = left.value();
+	return left = (value += right);
+}
+
+template<typename T, bool Se, typename T1> inline se_t<T, Se>& operator -=(se_t<T, Se>& left, const T1& right)
+{
+	auto value = left.value();
+	return left = (value -= right);
+}
+
+template<typename T, bool Se, typename T1> inline se_t<T, Se>& operator *=(se_t<T, Se>& left, const T1& right)
+{
+	auto value = left.value();
+	return left = (value *= right);
+}
+
+template<typename T, bool Se, typename T1> inline se_t<T, Se>& operator /=(se_t<T, Se>& left, const T1& right)
+{
+	auto value = left.value();
+	return left = (value /= right);
+}
+
+template<typename T, bool Se, typename T1> inline se_t<T, Se>& operator %=(se_t<T, Se>& left, const T1& right)
+{
+	auto value = left.value();
+	return left = (value %= right);
+}
+
+template<typename T, bool Se, typename T1> inline se_t<T, Se>& operator <<=(se_t<T, Se>& left, const T1& right)
+{
+	auto value = left.value();
+	return left = (value <<= right);
+}
+
+template<typename T, bool Se, typename T1> inline se_t<T, Se>& operator >>=(se_t<T, Se>& left, const T1& right)
+{
+	auto value = left.value();
+	return left = (value >>= right);
+}
+
+template<typename T, bool Se> inline se_t<T, Se> operator ++(se_t<T, Se>& left, int)
+{
+	auto value = left.value();
+	auto result = value++;
+	left = value;
+	return result;
+}
+
+template<typename T, bool Se> inline se_t<T, Se> operator --(se_t<T, Se>& left, int)
+{
+	auto value = left.value();
+	auto result = value--;
+	left = value;
+	return result;
+}
+
+template<typename T, bool Se> inline se_t<T, Se>& operator ++(se_t<T, Se>& right)
+{
+	auto value = right.value();
+	return right = ++value;
+}
+
+template<typename T, bool Se> inline se_t<T, Se>& operator --(se_t<T, Se>& right)
+{
+	auto value = right.value();
+	return right = --value;
+}
+
+// optimization
+template<typename T1, typename T2> inline std::enable_if_t<IS_BINARY_COMPARABLE(T1, T2), bool> operator ==(const se_t<T1>& left, const se_t<T2>& right)
+{
+	return left.raw_data() == right.raw_data();
+}
+
+// optimization
+template<typename T1, typename T2> inline std::enable_if_t<IS_INTEGRAL(T1) && IS_INTEGER(T2) && sizeof(T1) >= sizeof(T2), bool> operator ==(const se_t<T1>& left, T2 right)
+{
+	return left.raw_data() == se_storage<T1>::to(right);
+}
+
+// optimization
+template<typename T1, typename T2> inline std::enable_if_t<IS_INTEGER(T1) && IS_INTEGRAL(T2) && sizeof(T1) <= sizeof(T2), bool> operator ==(T1 left, const se_t<T2>& right)
+{
+	return se_storage<T2>::to(left) == right.raw_data();
+}
+
+// optimization
+template<typename T1, typename T2> inline std::enable_if_t<IS_BINARY_COMPARABLE(T1, T2), bool> operator !=(const se_t<T1>& left, const se_t<T2>& right)
+{
+	return left.raw_data() != right.raw_data();
+}
+
+// optimization
+template<typename T1, typename T2> inline std::enable_if_t<IS_INTEGRAL(T1) && IS_INTEGER(T2) && sizeof(T1) >= sizeof(T2), bool> operator !=(const se_t<T1>& left, T2 right)
+{
+	return left.raw_data() != se_storage<T1>::to(right);
+}
+
+// optimization
+template<typename T1, typename T2> inline std::enable_if_t<IS_INTEGER(T1) && IS_INTEGRAL(T2) && sizeof(T1) <= sizeof(T2), bool> operator !=(T1 left, const se_t<T2>& right)
+{
+	return se_storage<T2>::to(left) != right.raw_data();
+}
+
+// optimization
+template<typename T1, typename T2> inline std::enable_if_t<IS_BINARY_COMPARABLE(T1, T2) && sizeof(T1) >= 4, se_t<decltype(T1() & T2())>> operator &(const se_t<T1>& left, const se_t<T2>& right)
+{
+	return{ left.raw_data() & right.raw_data(), se_raw };
+}
+
+// optimization
+template<typename T1, typename T2> inline std::enable_if_t<IS_INTEGRAL(T1) && IS_INTEGER(T2) && sizeof(T1) >= sizeof(T2) && sizeof(T1) >= 4, se_t<decltype(T1() & T2())>> operator &(const se_t<T1>& left, T2 right)
+{
+	return{ left.raw_data() & se_storage<T1>::to(right), se_raw };
+}
+
+// optimization
+template<typename T1, typename T2> inline std::enable_if_t<IS_INTEGER(T1) && IS_INTEGRAL(T2) && sizeof(T1) <= sizeof(T2) && sizeof(T2) >= 4, se_t<decltype(T1() & T2())>> operator &(T1 left, const se_t<T2>& right)
+{
+	return{ se_storage<T2>::to(left) & right.raw_data(), se_raw };
+}
+
+// optimization
+template<typename T1, typename T2> inline std::enable_if_t<IS_BINARY_COMPARABLE(T1, T2) && sizeof(T1) >= 4, se_t<decltype(T1() | T2())>> operator |(const se_t<T1>& left, const se_t<T2>& right)
+{
+	return{ left.raw_data() | right.raw_data(), se_raw };
+}
+
+// optimization
+template<typename T1, typename T2> inline std::enable_if_t<IS_INTEGRAL(T1) && IS_INTEGER(T2) && sizeof(T1) >= sizeof(T2) && sizeof(T1) >= 4, se_t<decltype(T1() | T2())>> operator |(const se_t<T1>& left, T2 right)
+{
+	return{ left.raw_data() | se_storage<T1>::to(right), se_raw };
+}
+
+// optimization
+template<typename T1, typename T2> inline std::enable_if_t<IS_INTEGER(T1) && IS_INTEGRAL(T2) && sizeof(T1) <= sizeof(T2) && sizeof(T2) >= 4, se_t<decltype(T1() | T2())>> operator |(T1 left, const se_t<T2>& right)
+{
+	return{ se_storage<T2>::to(left) | right.raw_data(), se_raw };
+}
+
+// optimization
+template<typename T1, typename T2> inline std::enable_if_t<IS_BINARY_COMPARABLE(T1, T2) && sizeof(T1) >= 4, se_t<decltype(T1() ^ T2())>> operator ^(const se_t<T1>& left, const se_t<T2>& right)
+{
+	return{ left.raw_data() ^ right.raw_data(), se_raw };
+}
+
+// optimization
+template<typename T1, typename T2> inline std::enable_if_t<IS_INTEGRAL(T1) && IS_INTEGER(T2) && sizeof(T1) >= sizeof(T2) && sizeof(T1) >= 4, se_t<decltype(T1() ^ T2())>> operator ^(const se_t<T1>& left, T2 right)
+{
+	return{ left.raw_data() ^ se_storage<T1>::to(right), se_raw };
+}
+
+// optimization
+template<typename T1, typename T2> inline std::enable_if_t<IS_INTEGER(T1) && IS_INTEGRAL(T2) && sizeof(T1) <= sizeof(T2) && sizeof(T2) >= 4, se_t<decltype(T1() ^ T2())>> operator ^(T1 left, const se_t<T2>& right)
+{
+	return{ se_storage<T2>::to(left) ^ right.raw_data(), se_raw };
+}
+
+// optimization
+template<typename T> inline std::enable_if_t<IS_INTEGRAL(T) && sizeof(T) >= 4, se_t<decltype(~T())>> operator ~(const se_t<T>& right)
+{
+	return{ ~right.raw_data(), se_raw };
+}
+
+#ifdef IS_LE_MACHINE
+template<typename T> using be_t = se_t<T, true>;
+template<typename T> using le_t = se_t<T, false>;
+#else
+template<typename T> using be_t = se_t<T, false>;
+template<typename T> using le_t = se_t<T, true>;
+#endif
+
+template<typename T> struct is_be_t : public std::integral_constant<bool, false>
+{
+};
+
+template<typename T> struct is_be_t<be_t<T>> : public std::integral_constant<bool, true>
+{
+};
+
+template<typename T> struct is_be_t<const T> : public std::integral_constant<bool, is_be_t<T>::value>
+{
+};
+
+template<typename T> struct is_be_t<volatile T> : public std::integral_constant<bool, is_be_t<T>::value>
+{
+};
+
+// to_be_t helper struct
+template<typename T> struct to_be
+{
+	using type = std::conditional_t<std::is_arithmetic<T>::value || std::is_enum<T>::value || std::is_same<T, v128>::value || std::is_same<T, u128>::value, be_t<T>, T>;
+};
+
+// be_t<T> if possible, T otherwise
+template<typename T> using to_be_t = typename to_be<T>::type;
+
+template<typename T> struct to_be<const T> // move const qualifier
+{
+	using type = const to_be_t<T>;
+};
+
+template<typename T> struct to_be<volatile T> // move volatile qualifier
+{
+	using type = volatile to_be_t<T>;
+};
+
+template<> struct to_be<void> { using type = void; };
+template<> struct to_be<bool> { using type = bool; };
+template<> struct to_be<char> { using type = char; };
+template<> struct to_be<u8> { using type = u8; };
+template<> struct to_be<s8> { using type = s8; };
+
+template<typename T> struct is_le_t : public std::integral_constant<bool, false>
+{
+};
+
+template<typename T> struct is_le_t<le_t<T>> : public std::integral_constant<bool, true>
+{
+};
+
+template<typename T> struct is_le_t<const T> : public std::integral_constant<bool, is_le_t<T>::value>
+{
+};
+
+template<typename T> struct is_le_t<volatile T> : public std::integral_constant<bool, is_le_t<T>::value>
+{
+};
+
+template<typename T> struct to_le
+{
+	using type = std::conditional_t<std::is_arithmetic<T>::value || std::is_enum<T>::value || std::is_same<T, v128>::value || std::is_same<T, u128>::value, le_t<T>, T>;
+};
+
+// le_t<T> if possible, T otherwise
+template<typename T> using to_le_t = typename to_le<T>::type;
+
+template<typename T> struct to_le<const T> // move const qualifier
+{
+	using type = const to_le_t<T>;
+};
+
+template<typename T> struct to_le<volatile T> // move volatile qualifier
+{
+	using type = volatile to_le_t<T>;
+};
+
+template<> struct to_le<void> { using type = void; };
+template<> struct to_le<bool> { using type = bool; };
+template<> struct to_le<char> { using type = char; };
+template<> struct to_le<u8> { using type = u8; };
+template<> struct to_le<s8> { using type = s8; };
+
+// to_ne_t helper struct
+template<typename T> struct to_ne
+{
+	using type = T;
+};
+
+template<typename T, bool Se> struct to_ne<se_t<T, Se>>
+{
+	using type = T;
+};
+
+// restore native endianness for T: returns T for be_t<T> or le_t<T>, T otherwise
+template<typename T> using to_ne_t = typename to_ne<T>::type;
+
+template<typename T> struct to_ne<const T> // move const qualifier
+{
+	using type = const to_ne_t<T>;
+};
+
+template<typename T> struct to_ne<volatile T> // move volatile qualifier
+{
+	using type = volatile to_ne_t<T>;
+};

Utilities/File.cpp

@@ -0,0 +1,843 @@
+#include "stdafx.h"
+#include "Log.h"
+#include "File.h"
+
+#ifdef _WIN32
+#include <Windows.h>
+
+#define GET_API_ERROR static_cast<u64>(GetLastError())
+
+static_assert(fs::file::null == intptr_t(INVALID_HANDLE_VALUE) && fs::dir::null == fs::file::null, "Check fs::file::null definition");
+
+std::unique_ptr<wchar_t[]> to_wchar(const std::string& source)
+{
+	const auto length = source.size() + 1; // size + null terminator
+
+	const int size = source.size() < INT_MAX ? static_cast<int>(length) : throw EXCEPTION("Invalid source length (0x%llx)", source.size());
+
+	std::unique_ptr<wchar_t[]> buffer(new wchar_t[length]); // allocate buffer assuming that length is the max possible size
+
+	if (!MultiByteToWideChar(CP_UTF8, 0, source.c_str(), size, buffer.get(), size))
+	{
+		throw EXCEPTION("System error 0x%x", GetLastError());
+	}
+
+	return buffer;
+}
+
+void to_utf8(std::string& result, const wchar_t* source)
+{
+	const int length = lstrlenW(source); // source length
+
+	if (length == 0)
+	{
+		return result.clear();
+	}
+
+	const int size = WideCharToMultiByte(CP_UTF8, 0, source, length, NULL, 0, NULL, NULL); // output size
+
+	if (size <= 0)
+	{
+		throw EXCEPTION("System error 0x%x", GetLastError());
+	}
+
+	result.resize(size);
+
+	if (!WideCharToMultiByte(CP_UTF8, 0, source, length, &result.front(), size, NULL, NULL))
+	{
+		throw EXCEPTION("System error 0x%x", GetLastError());
+	}
+}
+
+time_t to_time_t(const ULARGE_INTEGER& ft)
+{
+	return ft.QuadPart / 10000000ULL - 11644473600ULL;
+}
+
+time_t to_time_t(const LARGE_INTEGER& ft)
+{
+	ULARGE_INTEGER v;
+	v.LowPart = ft.LowPart;
+	v.HighPart = ft.HighPart;
+
+	return to_time_t(v);
+}
+
+time_t to_time_t(const FILETIME& ft)
+{
+	ULARGE_INTEGER v;
+	v.LowPart = ft.dwLowDateTime;
+	v.HighPart = ft.dwHighDateTime;
+
+	return to_time_t(v);
+}
+
+bool truncate_file(const std::string& file, u64 length)
+{
+	// open the file
+	const auto handle = CreateFileW(to_wchar(file).get(), GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+
+	if (handle == INVALID_HANDLE_VALUE)
+	{
+		return false;
+	}
+
+	LARGE_INTEGER distance;
+	distance.QuadPart = length;
+
+	// seek and truncate
+	if (!SetFilePointerEx(handle, distance, NULL, FILE_BEGIN) || !SetEndOfFile(handle))
+	{
+		const auto error = GetLastError();
+		CloseHandle(handle);
+		SetLastError(error);
+		return false;
+	}
+
+	return CloseHandle(handle);
+}
+
+#else
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <unistd.h>
+#if defined(__APPLE__) || defined(__FreeBSD__)
+#include <copyfile.h>
+#else
+#include <sys/sendfile.h>
+#endif
+#include "errno.h"
+
+#define GET_API_ERROR static_cast<u64>(errno)
+
+#endif
+
+thread_local fse fs::g_tls_error = fse::ok;
+
+bool fs::stat(const std::string& path, stat_t& info)
+{
+	g_tls_error = fse::ok;
+
+#ifdef _WIN32
+	WIN32_FILE_ATTRIBUTE_DATA attrs;
+	if (!GetFileAttributesExW(to_wchar(path).get(), GetFileExInfoStandard, &attrs))
+	{
+		return false;
+	}
+
+	info.is_directory = (attrs.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
+	info.is_writable = (attrs.dwFileAttributes & FILE_ATTRIBUTE_READONLY) == 0;
+	info.size = (u64)attrs.nFileSizeLow | ((u64)attrs.nFileSizeHigh << 32);
+	info.atime = to_time_t(attrs.ftLastAccessTime);
+	info.mtime = to_time_t(attrs.ftLastWriteTime);
+	info.ctime = to_time_t(attrs.ftCreationTime);
+#else
+	struct stat file_info;
+	if (stat(path.c_str(), &file_info) < 0)
+	{
+		return false;
+	}
+
+	info.is_directory = S_ISDIR(file_info.st_mode);
+	info.is_writable = file_info.st_mode & 0200; // HACK: approximation
+	info.size = file_info.st_size;
+	info.atime = file_info.st_atime;
+	info.mtime = file_info.st_mtime;
+	info.ctime = file_info.st_ctime;
+#endif
+
+	return true;
+}
+
+bool fs::exists(const std::string& path)
+{
+	g_tls_error = fse::ok;
+
+#ifdef _WIN32
+	return GetFileAttributesW(to_wchar(path).get()) != 0xFFFFFFFF;
+#else
+	struct stat buffer;
+	return stat(path.c_str(), &buffer) == 0;
+#endif
+}
+
+bool fs::is_file(const std::string& file)
+{
+	g_tls_error = fse::ok;
+
+#ifdef _WIN32
+	DWORD attrs;
+	if ((attrs = GetFileAttributesW(to_wchar(file).get())) == INVALID_FILE_ATTRIBUTES)
+	{
+		return false;
+	}
+
+	return (attrs & FILE_ATTRIBUTE_DIRECTORY) == 0;
+#else
+	struct stat file_info;
+	if (stat(file.c_str(), &file_info) < 0)
+	{
+		return false;
+	}
+
+	return !S_ISDIR(file_info.st_mode);
+#endif
+}
+
+bool fs::is_dir(const std::string& dir)
+{
+	g_tls_error = fse::ok;
+
+#ifdef _WIN32
+	DWORD attrs;
+	if ((attrs = GetFileAttributesW(to_wchar(dir).get())) == INVALID_FILE_ATTRIBUTES)
+	{
+		return false;
+	}
+
+	return (attrs & FILE_ATTRIBUTE_DIRECTORY) != 0;
+#else
+	struct stat file_info;
+	if (stat(dir.c_str(), &file_info) < 0)
+	{
+		return false;
+	}
+
+	return S_ISDIR(file_info.st_mode);
+#endif
+}
+
+bool fs::create_dir(const std::string& dir)
+{
+	g_tls_error = fse::ok;
+
+#ifdef _WIN32
+	if (!CreateDirectoryW(to_wchar(dir).get(), NULL))
+#else
+	if (mkdir(dir.c_str(), 0777))
+#endif
+	{
+		LOG_WARNING(GENERAL, "Error creating directory '%s': 0x%llx", dir, GET_API_ERROR);
+		return false;
+	}
+
+	return true;
+}
+
+bool fs::create_path(const std::string& path)
+{
+	g_tls_error = fse::ok;
+
+	size_t start = 0;
+
+	while (true)
+	{
+		// maybe it could be more optimal if goes from the end recursively
+		size_t pos = path.find_first_of("/\\", start);
+
+		if (pos == std::string::npos)
+		{
+			pos = path.length();
+		}
+
+		std::string dir = path.substr(0, pos);
+
+		start = ++pos;
+
+		if (dir.size() == 0)
+		{
+			continue;
+		}
+
+		if (!is_dir(dir))
+		{
+			// if doesn't exist or not a dir
+			if (!create_dir(dir))
+			{
+				// if creating failed
+				return false;
+			}
+		}
+
+		if (pos >= path.length())
+		{
+			break;
+		}
+	}
+
+	return true;
+}
+
+bool fs::remove_dir(const std::string& dir)
+{
+	g_tls_error = fse::ok;
+
+#ifdef _WIN32
+	if (!RemoveDirectoryW(to_wchar(dir).get()))
+#else
+	if (rmdir(dir.c_str()))
+#endif
+	{
+		LOG_WARNING(GENERAL, "Error deleting directory '%s': 0x%llx", dir, GET_API_ERROR);
+		return false;
+	}
+
+	return true;
+}
+
+bool fs::rename(const std::string& from, const std::string& to)
+{
+	g_tls_error = fse::ok;
+
+#ifdef _WIN32
+	if (!MoveFileW(to_wchar(from).get(), to_wchar(to).get()))
+#else
+	if (rename(from.c_str(), to.c_str()))
+#endif
+	{
+		LOG_WARNING(GENERAL, "Error renaming '%s' to '%s': 0x%llx", from, to, GET_API_ERROR);
+		return false;
+	}
+
+	return true;
+}
+
+#ifndef _WIN32
+
+int OSCopyFile(const char* source, const char* destination, bool overwrite)
+{
+	/* This function was taken from http://stackoverflow.com/questions/2180079/how-can-i-copy-a-file-on-unix-using-c */
+
+	int input, output;
+	if ((input = open(source, O_RDONLY)) == -1)
+	{
+		return -1;
+	}
+	if ((output = open(destination, O_WRONLY | O_CREAT | (overwrite ? O_TRUNC : O_EXCL), 0666)) == -1)
+	{
+		close(input);
+		return -1;
+	}
+
+	//Here we use kernel-space copying for performance reasons
+#if defined(__APPLE__) || defined(__FreeBSD__)
+	//fcopyfile works on FreeBSD and OS X 10.5+ 
+	int result = fcopyfile(input, output, 0, COPYFILE_ALL);
+#else
+	//sendfile will work with non-socket output (i.e. regular file) on Linux 2.6.33+
+	off_t bytesCopied = 0;
+	struct stat fileinfo = { 0 };
+	fstat(input, &fileinfo);
+	int result = sendfile(output, input, &bytesCopied, fileinfo.st_size) == -1 ? -1 : 0;
+#endif
+
+	close(input);
+	close(output);
+
+	return result;
+}
+#endif
+
+bool fs::copy_file(const std::string& from, const std::string& to, bool overwrite)
+{
+	g_tls_error = fse::ok;
+
+#ifdef _WIN32
+	if (!CopyFileW(to_wchar(from).get(), to_wchar(to).get(), !overwrite))
+#else
+	if (OSCopyFile(from.c_str(), to.c_str(), overwrite))
+#endif
+	{
+		LOG_WARNING(GENERAL, "Error copying '%s' to '%s': 0x%llx", from, to, GET_API_ERROR);
+		return false;
+	}
+
+	return true;
+}
+
+bool fs::remove_file(const std::string& file)
+{
+	g_tls_error = fse::ok;
+
+#ifdef _WIN32
+	if (!DeleteFileW(to_wchar(file).get()))
+#else
+	if (unlink(file.c_str()))
+#endif
+	{
+		LOG_WARNING(GENERAL, "Error deleting file '%s': 0x%llx", file, GET_API_ERROR);
+		return false;
+	}
+
+	return true;
+}
+
+bool fs::truncate_file(const std::string& file, u64 length)
+{
+	g_tls_error = fse::ok;
+
+#ifdef _WIN32
+	if (!::truncate_file(file, length))
+#else
+	if (::truncate(file.c_str(), length))
+#endif
+	{
+		LOG_WARNING(GENERAL, "Error resizing file '%s' to 0x%llx: 0x%llx", file, length, GET_API_ERROR);
+		return false;
+	}
+
+	return true;
+}
+
+fs::file::~file()
+{
+	if (m_fd != null)
+	{
+#ifdef _WIN32
+		CloseHandle((HANDLE)m_fd);
+#else
+		::close(m_fd);
+#endif
+	}
+}
+
+bool fs::file::open(const std::string& filename, u32 mode)
+{
+	this->close();
+
+	g_tls_error = fse::ok;
+
+#ifdef _WIN32
+	DWORD access = 0;
+	switch (mode & (fom::read | fom::write | fom::append))
+	{
+	case fom::read: access |= GENERIC_READ; break;
+	case fom::read | fom::append: access |= GENERIC_READ; break;
+	case fom::write: access |= GENERIC_WRITE; break;
+	case fom::write | fom::append: access |= FILE_APPEND_DATA; break;
+	case fom::read | fom::write: access |= GENERIC_READ | GENERIC_WRITE; break;
+	case fom::read | fom::write | fom::append: access |= GENERIC_READ | FILE_APPEND_DATA; break;
+	default:
+	{
+		LOG_ERROR(GENERAL, "fs::file::open('%s') failed: neither fom::read nor fom::write specified (0x%x)", filename, mode);
+		return false;
+	}
+	}
+
+	DWORD disp = 0;
+	switch (mode & (fom::create | fom::trunc | fom::excl))
+	{
+	case 0: disp = OPEN_EXISTING; break;
+	case fom::create: disp = OPEN_ALWAYS; break;
+	case fom::trunc: disp = TRUNCATE_EXISTING; break;
+	case fom::create | fom::trunc: disp = CREATE_ALWAYS; break;
+	case fom::create | fom::excl: disp = CREATE_NEW; break;
+	case fom::create | fom::excl | fom::trunc: disp = CREATE_NEW; break;
+	}
+
+	if (!disp || (mode & ~(fom::read | fom::write | fom::append | fom::create | fom::trunc | fom::excl)))
+	{
+		LOG_ERROR(GENERAL, "fs::file::open('%s') failed: unknown mode specified (0x%x)", filename, mode);
+		return false;
+	}
+
+	m_fd = (intptr_t)CreateFileW(to_wchar(filename).get(), access, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, disp, FILE_ATTRIBUTE_NORMAL, NULL);
+#else
+	int flags = 0;
+
+	switch (mode & (fom::read | fom::write))
+	{
+	case fom::read: flags |= O_RDONLY; break;
+	case fom::write: flags |= O_WRONLY; break;
+	case fom::read | fom::write: flags |= O_RDWR; break;
+	default:
+	{
+		LOG_ERROR(GENERAL, "fs::file::open('%s') failed: neither fom::read nor fom::write specified (0x%x)", filename, mode);
+		return false;
+	}
+	}
+
+	if (mode & fom::append) flags |= O_APPEND;
+	if (mode & fom::create) flags |= O_CREAT;
+	if (mode & fom::trunc) flags |= O_TRUNC;
+	if (mode & fom::excl) flags |= O_EXCL;
+
+	if (((mode & fom::excl) && !(mode & fom::create)) || (mode & ~(fom::read | fom::write | fom::append | fom::create | fom::trunc | fom::excl)))
+	{
+		LOG_ERROR(GENERAL, "fs::file::open('%s') failed: unknown mode specified (0x%x)", filename, mode);
+		return false;
+	}
+
+	m_fd = ::open(filename.c_str(), flags, 0666);
+#endif
+
+	if (m_fd == null)
+	{
+		LOG_WARNING(GENERAL, "fs::file::open('%s', 0x%x) failed: error 0x%llx", filename, mode, GET_API_ERROR);
+		return false;
+	}
+
+	return true;
+}
+
+bool fs::file::trunc(u64 size) const
+{
+	g_tls_error = fse::ok;
+
+#ifdef _WIN32
+	LARGE_INTEGER old, pos;
+
+	pos.QuadPart = 0;
+	SetFilePointerEx((HANDLE)m_fd, pos, &old, FILE_CURRENT); // get old position
+
+	pos.QuadPart = size;
+	SetFilePointerEx((HANDLE)m_fd, pos, NULL, FILE_BEGIN); // set new position
+
+	SetEndOfFile((HANDLE)m_fd); // change file size
+
+	SetFilePointerEx((HANDLE)m_fd, old, NULL, FILE_BEGIN); // restore position
+
+	return true; // TODO
+#else
+	return !::ftruncate(m_fd, size);
+#endif
+}
+
+bool fs::file::stat(stat_t& info) const
+{
+	g_tls_error = fse::ok;
+
+#ifdef _WIN32
+	FILE_BASIC_INFO basic_info;
+
+	if (!GetFileInformationByHandleEx((HANDLE)m_fd, FileBasicInfo, &basic_info, sizeof(FILE_BASIC_INFO)))
+	{
+		return false;
+	}
+
+	info.is_directory = (basic_info.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
+	info.is_writable = (basic_info.FileAttributes & FILE_ATTRIBUTE_READONLY) == 0;
+	info.size = this->size();
+	info.atime = to_time_t(basic_info.LastAccessTime);
+	info.mtime = to_time_t(basic_info.ChangeTime);
+	info.ctime = to_time_t(basic_info.CreationTime);
+#else
+	struct stat file_info;
+	if (fstat(m_fd, &file_info) < 0)
+	{
+		return false;
+	}
+
+	info.is_directory = S_ISDIR(file_info.st_mode);
+	info.is_writable = file_info.st_mode & 0200; // HACK: approximation
+	info.size = file_info.st_size;
+	info.atime = file_info.st_atime;
+	info.mtime = file_info.st_mtime;
+	info.ctime = file_info.st_ctime;
+#endif
+
+	return true;
+}
+
+bool fs::file::close()
+{
+	g_tls_error = fse::ok;
+
+	if (m_fd == null)
+	{
+		return false;
+	}
+
+	auto fd = m_fd;
+	m_fd = null;
+
+#ifdef _WIN32
+	return CloseHandle((HANDLE)fd);
+#else
+	return !::close(fd);
+#endif
+}
+
+u64 fs::file::read(void* buffer, u64 count) const
+{
+	g_tls_error = fse::ok;
+
+	const int size = count <= INT_MAX ? static_cast<int>(count) : throw EXCEPTION("Invalid count (0x%llx)", count);
+
+#ifdef _WIN32
+	DWORD nread;
+	if (!ReadFile((HANDLE)m_fd, buffer, size, &nread, NULL))
+	{
+		return -1;
+	}
+
+	return nread;
+#else
+	return ::read(m_fd, buffer, size);
+#endif
+}
+
+u64 fs::file::write(const void* buffer, u64 count) const
+{
+	g_tls_error = fse::ok;
+
+	const int size = count <= INT_MAX ? static_cast<int>(count) : throw EXCEPTION("Invalid count (0x%llx)", count);
+
+#ifdef _WIN32
+	DWORD nwritten;
+	if (!WriteFile((HANDLE)m_fd, buffer, size, &nwritten, NULL))
+	{
+		return -1;
+	}
+
+	return nwritten;
+#else
+	return ::write(m_fd, buffer, size);
+#endif
+}
+
+u64 fs::file::seek(s64 offset, fsm seek_mode) const
+{
+	g_tls_error = fse::ok;
+
+#ifdef _WIN32
+	LARGE_INTEGER pos;
+	pos.QuadPart = offset;
+
+	const DWORD mode =
+		seek_mode == fsm::begin ? FILE_BEGIN :
+		seek_mode == fsm::cur ? FILE_CURRENT :
+		seek_mode == fsm::end ? FILE_END :
+		throw EXCEPTION("Unknown seek_mode (0x%x)", seek_mode);
+
+	if (!SetFilePointerEx((HANDLE)m_fd, pos, &pos, mode))
+	{
+		return -1;
+	}
+
+	return pos.QuadPart;
+#else
+	const int whence =
+		seek_mode == fsm::begin ? SEEK_SET :
+		seek_mode == fsm::cur ? SEEK_CUR :
+		seek_mode == fsm::end ? SEEK_END :
+		throw EXCEPTION("Unknown seek_mode (0x%x)", seek_mode);
+
+	return ::lseek(m_fd, offset, whence);
+#endif
+}
+
+u64 fs::file::size() const
+{
+	g_tls_error = fse::ok;
+
+#ifdef _WIN32
+	LARGE_INTEGER size;
+	if (!GetFileSizeEx((HANDLE)m_fd, &size))
+	{
+		return -1;
+	}
+
+	return size.QuadPart;
+#else
+	struct stat file_info;
+	if (::fstat(m_fd, &file_info) < 0)
+	{
+		return -1;
+	}
+
+	return file_info.st_size;
+#endif
+}
+
+fs::dir::~dir()
+{
+	if (m_dd != null)
+	{
+#ifdef _WIN32
+		FindClose((HANDLE)m_dd);
+#else
+		::closedir((DIR*)m_dd);
+#endif
+	}
+}
+
+void fs::dir::import(handle_type dd, const std::string& path)
+{
+	if (m_dd != null)
+	{
+#ifdef _WIN32
+		FindClose((HANDLE)m_dd);
+#else
+		::closedir((DIR*)m_dd);
+#endif
+	}
+
+	g_tls_error = fse::ok;
+
+	m_dd = dd;
+
+#ifdef _WIN32
+	m_path = to_wchar(path);
+#else
+	m_path.reset(new char[path.size() + 1]);
+	memcpy(m_path.get(), path.c_str(), path.size() + 1);
+#endif
+}
+
+bool fs::dir::open(const std::string& dirname)
+{
+	if (m_dd != null)
+	{
+#ifdef _WIN32
+		FindClose((HANDLE)m_dd);
+#else
+		::closedir((DIR*)m_dd);
+#endif
+	}
+
+	g_tls_error = fse::ok;
+
+	m_dd = null;
+
+	m_path.reset();
+
+	if (!is_dir(dirname))
+	{
+		return false;
+	}
+
+#ifdef _WIN32
+	m_path = to_wchar(dirname + "/*");
+#else
+	m_path.reset(new char[dirname.size() + 1]);
+	memcpy(m_path.get(), dirname.c_str(), dirname.size() + 1);
+#endif
+
+	return true;
+}
+
+bool fs::dir::close()
+{
+	g_tls_error = fse::ok;
+
+	if (m_dd == null)
+	{
+		if (m_path)
+		{
+			m_path.reset();
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
+
+	auto dd = m_dd;
+	m_dd = null;
+
+	m_path.reset();
+
+#ifdef _WIN32
+	return FindClose((HANDLE)dd);
+#else
+	return !::closedir((DIR*)dd);
+#endif
+}
+
+bool fs::dir::get_first(std::string& name, stat_t& info)
+{
+	if (m_dd != null) // close previous handle
+	{
+#ifdef _WIN32
+		FindClose((HANDLE)m_dd);
+#else
+		::closedir((DIR*)m_dd);
+#endif
+	}
+
+	g_tls_error = fse::ok;
+
+	m_dd = null;
+
+	if (!m_path)
+	{
+		return false;
+	}
+
+#ifdef _WIN32
+	WIN32_FIND_DATAW found;
+
+	m_dd = (intptr_t)FindFirstFileW(m_path.get(), &found);
+
+	if (m_dd == null)
+	{
+		return false;
+	}
+
+	to_utf8(name, found.cFileName);
+
+	info.is_directory = (found.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
+	info.is_writable = (found.dwFileAttributes & FILE_ATTRIBUTE_READONLY) == 0;
+	info.size = ((u64)found.nFileSizeHigh << 32) | (u64)found.nFileSizeLow;
+	info.atime = to_time_t(found.ftLastAccessTime);
+	info.mtime = to_time_t(found.ftLastWriteTime);
+	info.ctime = to_time_t(found.ftCreationTime);
+
+	return true;
+#else
+	m_dd = (intptr_t)::opendir(m_path.get());
+
+	return get_next(name, info);
+#endif
+}
+
+bool fs::dir::get_next(std::string& name, stat_t& info)
+{
+	g_tls_error = fse::ok;
+
+	if (m_dd == null)
+	{
+		return false;
+	}
+
+#ifdef _WIN32
+	WIN32_FIND_DATAW found;
+
+	if (!FindNextFileW((HANDLE)m_dd, &found))
+	{
+		return false;
+	}
+
+	to_utf8(name, found.cFileName);
+
+	info.is_directory = (found.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
+	info.is_writable = (found.dwFileAttributes & FILE_ATTRIBUTE_READONLY) == 0;
+	info.size = ((u64)found.nFileSizeHigh << 32) | (u64)found.nFileSizeLow;
+	info.atime = to_time_t(found.ftLastAccessTime);
+	info.mtime = to_time_t(found.ftLastWriteTime);
+	info.ctime = to_time_t(found.ftCreationTime);
+#else
+	const auto found = ::readdir((DIR*)m_dd);
+
+	struct stat file_info;
+	if (!found || ::fstatat(::dirfd((DIR*)m_dd), found->d_name, &file_info, 0) < 0)
+	{
+		return false;
+	}
+
+	name = found->d_name;
+
+	info.is_directory = S_ISDIR(file_info.st_mode);
+	info.is_writable = file_info.st_mode & 0200; // HACK: approximation
+	info.size = file_info.st_size;
+	info.atime = file_info.st_atime;
+	info.mtime = file_info.st_mtime;
+	info.ctime = file_info.st_ctime;
+#endif
+
+	return true;
+}

Utilities/File.h

@@ -0,0 +1,143 @@
+#pragma once
+
+enum class fsm : u32 // file seek mode
+{
+	begin,
+	cur,
+	end,
+};
+
+namespace fom // file open mode
+{
+	enum : u32
+	{
+		read = 1 << 0,
+		write = 1 << 1,
+		append = 1 << 2,
+		create = 1 << 3,
+		trunc = 1 << 4,
+		excl = 1 << 5,
+	};
+};
+
+enum class fse : u32 // filesystem (file or dir) error
+{
+	ok, // no error
+	invalid_arguments,
+};
+
+enum : u32 // obsolete flags
+{
+	o_read = fom::read,
+	o_write = fom::write,
+	o_append = fom::append,
+	o_create = fom::create,
+	o_trunc = fom::trunc,
+	o_excl = fom::excl,
+};
+
+namespace fs
+{
+	thread_local extern fse g_tls_error;
+
+	struct stat_t
+	{
+		bool is_directory;
+		bool is_writable;
+		u64 size;
+		s64 atime;
+		s64 mtime;
+		s64 ctime;
+	};
+
+	bool stat(const std::string& path, stat_t& info);
+	bool exists(const std::string& path);
+	bool is_file(const std::string& file);
+	bool is_dir(const std::string& dir);
+	bool remove_dir(const std::string& dir);
+	bool create_dir(const std::string& dir);
+	bool create_path(const std::string& path);
+	bool rename(const std::string& from, const std::string& to);
+	bool copy_file(const std::string& from, const std::string& to, bool overwrite);
+	bool remove_file(const std::string& file);
+	bool truncate_file(const std::string& file, u64 length);
+
+	struct file final
+	{
+		using handle_type = std::intptr_t;
+
+		static const handle_type null = -1;
+
+	private:
+		handle_type m_fd = null;
+
+	public:
+		file() = default;
+		~file();
+		explicit file(const std::string& filename, u32 mode = fom::read) { open(filename, mode); }
+
+		file(const file&) = delete;
+		file(file&&) = delete; // possibly TODO
+
+		file& operator =(const file&) = delete;
+		file& operator =(file&&) = delete; // possibly TODO
+
+		operator bool() const { return m_fd != null; }
+
+		void import(handle_type fd) { this->~file(); m_fd = fd; }
+
+		bool open(const std::string& filename, u32 mode = fom::read);
+		bool is_opened() const { return m_fd != null; }
+		bool trunc(u64 size) const; // change file size (possibly appending zero bytes)
+		bool stat(stat_t& info) const; // get file info
+		bool close();
+
+		u64 read(void* buffer, u64 count) const;
+		u64 write(const void* buffer, u64 count) const;
+		u64 seek(s64 offset, fsm seek_mode = fsm::begin) const;
+		u64 size() const;
+	};
+
+	struct dir final
+	{
+#ifdef _WIN32
+		using handle_type = intptr_t;
+		using name_type = std::unique_ptr<wchar_t[]>;
+
+		static const handle_type null = -1;
+#else
+		using handle_type = intptr_t;
+		using name_type = std::unique_ptr<char[]>;
+
+		static const handle_type null = 0;
+#endif
+
+	private:
+		handle_type m_dd = null;
+		name_type m_path;
+
+	public:
+		dir() = default;
+		~dir();
+		explicit dir(const std::string& dirname) { open(dirname); }
+
+		dir(const dir&) = delete;
+		dir(dir&&) = delete; // possibly TODO
+
+		dir& operator =(const dir&) = delete;
+		dir& operator =(dir&&) = delete; // possibly TODO
+
+		operator bool() const { return m_path.operator bool(); }
+
+		void import(handle_type dd, const std::string& path);
+
+		bool open(const std::string& dirname);
+		bool is_opened() const { return *this; }
+		bool close();
+
+		bool get_first(std::string& name, stat_t& info);
+		//bool get_first(std::string& name);
+		bool get_next(std::string& name, stat_t& info);
+		//bool get_next(std::string& name);
+	};
+}

Utilities/GNU.cpp

@@ -0,0 +1,59 @@
+#include "GNU.h"
+
+#ifdef __APPLE__
+#include <sys/types.h>
+#include <sys/_types/_timespec.h>
+#include <mach/mach.h>
+#include <mach/clock.h>
+#include <mach/mach_time.h>
+#undef CPU_STATE_MAX
+
+#define MT_NANO (+1.0E-9)
+#define MT_GIGA UINT64_C(1000000000)
+
+// TODO create a list of timers,
+static double mt_timebase = 0.0;
+static uint64_t mt_timestart = 0;
+
+// TODO be more careful in a multithreaded environement
+int clock_gettime(clockid_t clk_id, struct timespec *tp)
+{
+    kern_return_t retval = KERN_SUCCESS;
+    if( clk_id == TIMER_ABSTIME)
+    {
+        if (!mt_timestart) { // only one timer, initilized on the first call to the TIMER
+            mach_timebase_info_data_t tb = { 0 };
+            mach_timebase_info(&tb);
+            mt_timebase = tb.numer;
+            mt_timebase /= tb.denom;
+            mt_timestart = mach_absolute_time();
+        }
+
+        double diff = (mach_absolute_time() - mt_timestart) * mt_timebase;
+        tp->tv_sec = diff * MT_NANO;
+        tp->tv_nsec = diff - (tp->tv_sec * MT_GIGA);
+    }
+    else // other clk_ids are mapped to the coresponding mach clock_service
+    {
+        clock_serv_t cclock;
+        mach_timespec_t mts;
+
+        host_get_clock_service(mach_host_self(), clk_id, &cclock);
+        retval = clock_get_time(cclock, &mts);
+        mach_port_deallocate(mach_task_self(), cclock);
+
+        tp->tv_sec = mts.tv_sec;
+        tp->tv_nsec = mts.tv_nsec;
+    }
+
+    return retval;
+}
+#endif /* __APPLE__ */
+#if defined(__GNUG__)
+
+void * _aligned_malloc(size_t size, size_t alignment) {
+	void *buffer;
+	return (posix_memalign(&buffer, alignment, size) == 0) ? buffer : 0;
+}
+#endif
+

Utilities/GNU.h

@@ -0,0 +1,329 @@
+#pragma once
+
+#include <emmintrin.h>
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+#define thread_local __declspec(thread)
+#elif __APPLE__
+#define thread_local __thread
+#endif
+
+#if defined(_MSC_VER)
+#define never_inline __declspec(noinline)
+#else
+#define never_inline __attribute__((noinline))
+#endif
+
+#if defined(_MSC_VER)
+#define safe_buffers __declspec(safebuffers)
+#else
+#define safe_buffers
+#endif
+
+#if defined(_MSC_VER)
+#define force_inline __forceinline
+#else
+#define force_inline __attribute__((always_inline))
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+#define alignas(x) _CRT_ALIGN(x)
+#endif
+
+#if defined(__GNUG__)
+
+#include <stdlib.h>
+#include <cstdint>
+
+#ifndef __APPLE__
+#include <malloc.h>
+#endif
+
+#define _fpclass(x) std::fpclassify(x)
+#define _byteswap_ushort(x) __builtin_bswap16(x)
+#define _byteswap_ulong(x) __builtin_bswap32(x)
+#define _byteswap_uint64(x) __builtin_bswap64(x)
+#define INFINITE 0xFFFFFFFF
+
+inline uint64_t __umulh(uint64_t a, uint64_t b)
+{
+	uint64_t result;
+	__asm__("mulq %[b]" : "=d" (result) : [a] "a" (a), [b] "rm" (b));
+	return result;
+}
+
+inline int64_t  __mulh(int64_t a, int64_t b)
+{
+	int64_t result;
+	__asm__("imulq %[b]" : "=d" (result) : [a] "a" (a), [b] "rm" (b));
+	return result;
+}
+
+#ifdef __APPLE__
+
+// XXX only supports a single timer
+#define TIMER_ABSTIME -1
+/* The opengroup spec isn't clear on the mapping from REALTIME to CALENDAR
+ being appropriate or not.
+ http://pubs.opengroup.org/onlinepubs/009695299/basedefs/time.h.html */
+#define CLOCK_REALTIME  1 // #define CALENDAR_CLOCK 1 from mach/clock_types.h
+#define CLOCK_MONOTONIC 0 // #define SYSTEM_CLOCK 0
+
+typedef int clockid_t;
+
+/* the mach kernel uses struct mach_timespec, so struct timespec
+    is loaded from <sys/_types/_timespec.h> for compatability */
+// struct timespec { time_t tv_sec; long tv_nsec; };
+
+int clock_gettime(clockid_t clk_id, struct timespec *tp);
+
+#endif /* __APPLE__ */
+#endif /* __GNUG__ */
+
+#if defined(_MSC_VER)
+// Unsigned 128-bit integer implementation
+struct alignas(16) uint128_t
+{
+	uint64_t lo, hi;
+
+	uint128_t() = default;
+
+	uint128_t(uint64_t l)
+		: lo(l)
+		, hi(0)
+	{
+	}
+
+	[[deprecated("Not implemented")]] inline uint128_t operator +(const uint128_t& r) const
+	{
+		return{};
+	}
+
+	inline uint128_t operator +(uint64_t r) const
+	{
+		uint128_t value;
+		value.lo = lo + r;
+		value.hi = value.lo < r ? hi + 1 : hi;
+		return value;
+	}
+
+	[[deprecated("Not implemented")]] inline uint128_t operator -(const uint128_t& r) const
+	{
+		return{};
+	}
+
+	inline uint128_t operator -(uint64_t r) const
+	{
+		uint128_t value;
+		value.lo = lo - r;
+		value.hi = lo < r ? hi - 1 : hi;
+		return value;
+	}
+
+	inline uint128_t operator +() const
+	{
+		return *this;
+	}
+
+	inline uint128_t operator -() const
+	{
+		uint128_t value;
+		value.lo = ~lo + 1;
+		value.hi = lo ? ~hi : ~hi + 1;
+		return value;
+	}
+
+	inline uint128_t& operator ++()
+	{
+		if (!++lo) ++hi;
+		return *this;
+	}
+
+	inline uint128_t operator ++(int)
+	{
+		uint128_t value = *this;
+		if (!++lo) ++hi;
+		return value;
+	}
+
+	inline uint128_t& operator --()
+	{
+		if (!lo--) hi--;
+		return *this;
+	}
+
+	inline uint128_t operator --(int)
+	{
+		uint128_t value = *this;
+		if (!lo--) hi--;
+		return value;
+	}
+
+	inline uint128_t operator ~() const
+	{
+		uint128_t value;
+		value.lo = ~lo;
+		value.hi = ~hi;
+		return value;
+	}
+
+	inline uint128_t operator &(const uint128_t& r) const
+	{
+		uint128_t value;
+		value.lo = lo & r.lo;
+		value.hi = hi & r.hi;
+		return value;
+	}
+
+	inline uint128_t operator |(const uint128_t& r) const
+	{
+		uint128_t value;
+		value.lo = lo | r.lo;
+		value.hi = hi | r.hi;
+		return value;
+	}
+
+	inline uint128_t operator ^(const uint128_t& r) const
+	{
+		uint128_t value;
+		value.lo = lo ^ r.lo;
+		value.hi = hi ^ r.hi;
+		return value;
+	}
+
+	[[deprecated("Not implemented")]] inline uint128_t& operator +=(const uint128_t& r)
+	{
+		return *this;
+	}
+
+	inline uint128_t& operator +=(uint64_t r)
+	{
+		hi = (lo += r) < r ? hi + 1 : hi;
+		return *this;
+	}
+
+	[[deprecated("Not implemented")]] inline uint128_t& operator -=(const uint128_t& r)
+	{
+		return *this;
+	}
+
+	inline uint128_t& operator &=(const uint128_t& r)
+	{
+		lo &= r.lo;
+		hi &= r.hi;
+		return *this;
+	}
+
+	inline uint128_t& operator |=(const uint128_t& r)
+	{
+		lo |= r.lo;
+		hi |= r.hi;
+		return *this;
+	}
+
+	inline uint128_t& operator ^=(const uint128_t& r)
+	{
+		lo ^= r.lo;
+		hi ^= r.hi;
+		return *this;
+	}
+};
+
+using __uint128_t = uint128_t;
+#endif
+
+inline uint32_t cntlz32(uint32_t arg)
+{
+#if defined(_MSC_VER)
+	unsigned long res;
+	if (!_BitScanReverse(&res, arg))
+	{
+		return 32;
+	}
+	else
+	{
+		return res ^ 31;
+	}
+#else
+	if (arg)
+	{
+		return __builtin_clzll((uint64_t)arg) - 32;
+	}
+	else
+	{
+		return 32;
+	}
+#endif
+}
+
+inline uint64_t cntlz64(uint64_t arg)
+{
+#if defined(_MSC_VER)
+	unsigned long res;
+	if (!_BitScanReverse64(&res, arg))
+	{
+		return 64;
+	}
+	else
+	{
+		return res ^ 63;
+	}
+#else
+	if (arg)
+	{
+		return __builtin_clzll(arg);
+	}
+	else
+	{
+		return 64;
+	}
+#endif
+}
+
+// compare 16 packed unsigned bytes (greater than)
+inline __m128i sse_cmpgt_epu8(__m128i A, __m128i B)
+{
+	// (A xor 0x80) > (B xor 0x80)
+	const auto sign = _mm_set1_epi32(0x80808080);
+	return _mm_cmpgt_epi8(_mm_xor_si128(A, sign), _mm_xor_si128(B, sign));
+}
+
+inline __m128i sse_cmpgt_epu16(__m128i A, __m128i B)
+{
+	const auto sign = _mm_set1_epi32(0x80008000);
+	return _mm_cmpgt_epi16(_mm_xor_si128(A, sign), _mm_xor_si128(B, sign));
+}
+
+inline __m128i sse_cmpgt_epu32(__m128i A, __m128i B)
+{
+	const auto sign = _mm_set1_epi32(0x80000000);
+	return _mm_cmpgt_epi32(_mm_xor_si128(A, sign), _mm_xor_si128(B, sign));
+}
+
+inline __m128 sse_exp2_ps(__m128 A)
+{
+	const auto x0 = _mm_max_ps(_mm_min_ps(A, _mm_set1_ps(127.4999961f)), _mm_set1_ps(-127.4999961f));
+	const auto x1 = _mm_add_ps(x0, _mm_set1_ps(0.5f));
+	const auto x2 = _mm_sub_epi32(_mm_cvtps_epi32(x1), _mm_and_si128(_mm_castps_si128(_mm_cmpnlt_ps(_mm_setzero_ps(), x1)), _mm_set1_epi32(1)));
+	const auto x3 = _mm_sub_ps(x0, _mm_cvtepi32_ps(x2));
+	const auto x4 = _mm_mul_ps(x3, x3);
+	const auto x5 = _mm_mul_ps(x3, _mm_add_ps(_mm_mul_ps(_mm_add_ps(_mm_mul_ps(x4, _mm_set1_ps(0.023093347705f)), _mm_set1_ps(20.20206567f)), x4), _mm_set1_ps(1513.906801f)));
+	const auto x6 = _mm_mul_ps(x5, _mm_rcp_ps(_mm_sub_ps(_mm_add_ps(_mm_mul_ps(_mm_set1_ps(233.1842117f), x4), _mm_set1_ps(4368.211667f)), x5)));
+	return _mm_mul_ps(_mm_add_ps(_mm_add_ps(x6, x6), _mm_set1_ps(1.0f)), _mm_castsi128_ps(_mm_slli_epi32(_mm_add_epi32(x2, _mm_set1_epi32(127)), 23)));
+}
+
+inline __m128 sse_log2_ps(__m128 A)
+{
+	const auto _1 = _mm_set1_ps(1.0f);
+	const auto _c = _mm_set1_ps(1.442695040f);
+	const auto x0 = _mm_max_ps(A, _mm_castsi128_ps(_mm_set1_epi32(0x00800000)));
+	const auto x1 = _mm_or_ps(_mm_and_ps(x0, _mm_castsi128_ps(_mm_set1_epi32(0x807fffff))), _1);
+	const auto x2 = _mm_rcp_ps(_mm_add_ps(x1, _1));
+	const auto x3 = _mm_mul_ps(_mm_sub_ps(x1, _1), x2);
+	const auto x4 = _mm_add_ps(x3, x3);
+	const auto x5 = _mm_mul_ps(x4, x4);
+	const auto x6 = _mm_add_ps(_mm_mul_ps(_mm_add_ps(_mm_mul_ps(_mm_set1_ps(-0.7895802789f), x5), _mm_set1_ps(16.38666457f)), x5), _mm_set1_ps(-64.1409953f));
+	const auto x7 = _mm_rcp_ps(_mm_add_ps(_mm_mul_ps(_mm_add_ps(_mm_mul_ps(_mm_set1_ps(-35.67227983f), x5), _mm_set1_ps(312.0937664f)), x5), _mm_set1_ps(-769.6919436f)));
+	const auto x8 = _mm_cvtepi32_ps(_mm_sub_epi32(_mm_srli_epi32(_mm_castps_si128(x0), 23), _mm_set1_epi32(127)));
+	return _mm_add_ps(_mm_mul_ps(_mm_mul_ps(_mm_mul_ps(_mm_mul_ps(x5, x6), x7), x4), _c), _mm_add_ps(_mm_mul_ps(x4, _c), x8));
+}

Utilities/IdManager.h

@@ -1,136 +0,0 @@
-#pragma once
-#include "Array.h"
-
-typedef u32 ID_TYPE;
-
-struct ID
-{
-	bool m_used;
-	wxString m_name;
-	u8 m_attr;
-	void* m_data;
-
-	ID(bool used = false, const wxString& name = wxEmptyString, void* data = NULL, const u8 attr = 0)
-		: m_used(used)
-		, m_name(name)
-		, m_data(data)
-		, m_attr(attr)
-	{
-	}
-};
-
-class IdManager
-{
-	ArrayF<ID> IDs;
-
-	static const u64 first_id = 1;
-
-	void Cleanup()
-	{
-		while(IDs.GetCount())
-		{
-			const u32 num = IDs.GetCount()-1;
-			ID& id = IDs[num];
-			if(id.m_used) break;
-			IDs.RemoveAt(num);
-		}
-	}
-	
-public:
-	IdManager()
-	{
-	}
-	
-	~IdManager()
-	{
-		Clear();
-	}
-	
-	static ID_TYPE GetMaxID()
-	{
-		return (ID_TYPE)-1;
-	}
-	
-	bool CheckID(const u64 id)
-	{
-		if(id == 0 || id > (u64)NumToID(IDs.GetCount()-1) || id >= GetMaxID()) return false;
-
-		return IDs[IDToNum(id)].m_used;
-	}
-	
-	__forceinline const ID_TYPE NumToID(const ID_TYPE num) const
-	{
-		return num + first_id;
-	}
-	
-	__forceinline const ID_TYPE IDToNum(const ID_TYPE id) const
-	{
-		return id - first_id;
-	}
-
-	void Clear()
-	{
-		IDs.Clear();
-	}
-	
-	virtual ID_TYPE GetNewID(const wxString& name = wxEmptyString, void* data = NULL, const u8 attr = 0)
-	{
-		for(uint i=0; i<IDs.GetCount(); ++i)
-		{
-			if(IDs[i].m_used) continue;
-			return NumToID(i);
-		}
-
-		const ID_TYPE pos = IDs.GetCount();
-		if(NumToID(pos) >= GetMaxID()) return 0;
-		IDs.Add(new ID(true, name, data, attr));
-		return NumToID(pos);
-	}
-	
-	ID& GetIDData(const ID_TYPE _id)
-	{
-		//if(!CheckID(_id)) return IDs.Get(0); //TODO
-		return IDs[IDToNum(_id)];
-	}
-	
-
-	bool GetFirst(ID& dst, ID_TYPE* _id = NULL)
-	{
-		u32 pos = 0;
-		return GetNext(pos, dst, _id);
-	}
-
-	bool HasID(const s64 id)
-	{
-		if(id == wxID_ANY) return IDs.GetCount() != 0;
-		return CheckID(id);
-	}
-
-	bool GetNext(u32& pos, ID& dst, ID_TYPE* _id = NULL)
-	{
-		while(pos < IDs.GetCount())
-		{
-			ID& id = IDs[pos++];
-			if(!id.m_used) continue;
-			dst = id;
-			if(_id) *_id = NumToID(pos - 1);
-			return true;
-		}
-
-		return false;
-	}
-
-	virtual bool RemoveID(const ID_TYPE _id, bool free_data = true)
-	{
-		if(!CheckID(_id)) return false;
-		ID& id = IDs[IDToNum(_id)];
-		if(!id.m_used) return false;
-		id.m_used = false;
-		id.m_attr = 0;
-		id.m_name.Clear();
-		if(free_data) delete id.m_data;
-		id.m_data = NULL;
-		if(IDToNum(_id) == IDs.GetCount()-1) Cleanup();
-		return true;
-	}
-};

Utilities/Interval.h

@@ -0,0 +1,32 @@
+#pragma once
+
+template<typename T1, typename T2> struct range_t
+{
+	T1 _min; // first value
+	T2 _max; // second value
+};
+
+template<typename T1, typename T2> constexpr range_t<std::decay_t<T1>, std::decay_t<T2>> make_range(T1&& _min, T2&& _max)
+{
+	return{ std::forward<T1>(_min), std::forward<T2>(_max) };
+}
+
+template<typename T1, typename T2, typename T> constexpr bool operator <(const range_t<T1, T2>& range, const T& value)
+{
+	return range._min < value && range._max < value;
+}
+
+template<typename T1, typename T2, typename T> constexpr bool operator <(const T& value, const range_t<T1, T2>& range)
+{
+	return value < range._min && value < range._max;
+}
+
+template<typename T1, typename T2, typename T> constexpr bool operator ==(const range_t<T1, T2>& range, const T& value)
+{
+	return !(value < range._min) && !(range._max < value);
+}
+
+template<typename T1, typename T2, typename T> constexpr bool operator ==(const T& value, const range_t<T1, T2>& range)
+{
+	return !(value < range._min) && !(range._max < value);
+}

Utilities/Log.cpp

@@ -0,0 +1,276 @@
+#include "stdafx.h"
+#include "rPlatform.h"
+#include "Log.h"
+#include "rMsgBox.h"
+#include <iostream>
+#include <cinttypes>
+#include "Thread.h"
+#include "File.h"
+
+using namespace Log;
+
+std::unique_ptr<LogManager> g_log_manager;
+
+u32 LogMessage::size() const
+{
+	//1 byte for NULL terminator
+	return (u32)(sizeof(LogMessage::size_type) + sizeof(LogType) + sizeof(Severity) + sizeof(std::string::value_type) * mText.size() + 1);
+}
+
+void LogMessage::serialize(char *output) const
+{
+	LogMessage::size_type size = this->size();
+	memcpy(output, &size, sizeof(LogMessage::size_type));
+	output += sizeof(LogMessage::size_type);
+	memcpy(output, &mType, sizeof(LogType));
+	output += sizeof(LogType);
+	memcpy(output, &mServerity, sizeof(Severity));
+	output += sizeof(Severity);
+	memcpy(output, mText.c_str(), mText.size() );
+	output += sizeof(std::string::value_type)*mText.size();
+	*output = '\0';
+
+}
+LogMessage LogMessage::deserialize(char *input, u32* size_out)
+{
+	LogMessage msg;
+	LogMessage::size_type msgSize = *(reinterpret_cast<LogMessage::size_type*>(input));
+	input += sizeof(LogMessage::size_type);
+	msg.mType = *(reinterpret_cast<LogType*>(input));
+	input += sizeof(LogType);
+	msg.mServerity = *(reinterpret_cast<Severity*>(input));
+	input += sizeof(Severity);
+	if (msgSize > 9000)
+	{
+		int wtf = 6;
+	}
+	msg.mText.append(input, msgSize - 1 - sizeof(Severity) - sizeof(LogType));
+	if (size_out){(*size_out) = msgSize;}
+	return msg;
+}
+
+
+
+LogChannel::LogChannel() : LogChannel("unknown")
+{}
+
+LogChannel::LogChannel(const std::string& name) :
+	  name(name)
+	, mEnabled(true)
+	, mLogLevel(Severity::Warning)
+{}
+
+void LogChannel::log(const LogMessage &msg)
+{
+	std::lock_guard<std::mutex> lock(mListenerLock);
+	for (auto &listener : mListeners)
+	{
+		listener->log(msg);
+	}
+}
+
+void LogChannel::addListener(std::shared_ptr<LogListener> listener)
+{
+	std::lock_guard<std::mutex> lock(mListenerLock);
+	mListeners.insert(listener);
+}
+void LogChannel::removeListener(std::shared_ptr<LogListener> listener)
+{
+	std::lock_guard<std::mutex> lock(mListenerLock);
+	mListeners.erase(listener);
+}
+
+struct CoutListener : LogListener
+{
+	void log(const LogMessage &msg) override
+	{
+		std::cerr << msg.mText << std::endl;
+	}
+};
+
+struct FileListener : LogListener
+{
+	fs::file mFile;
+	bool mPrependChannelName;
+
+	FileListener(const std::string& name = _PRGNAME_, bool prependChannel = true)
+		: mFile(rPlatform::getConfigDir() + name + ".log", fom::write | fom::create | fom::trunc)
+		, mPrependChannelName(prependChannel)
+	{
+		if (!mFile)
+		{
+			rMessageBox("Can't create log file! (" + name + ".log)", "Error", rICON_ERROR);
+		}
+	}
+
+	void log(const LogMessage &msg) override
+	{
+		std::string text = msg.mText;
+		if (mPrependChannelName)
+		{
+			text.insert(0, gTypeNameTable[static_cast<u32>(msg.mType)].mName);
+			
+			if (msg.mType == Log::TTY)
+			{
+				text = fmt::escape(text);
+				if (text[text.length() - 1] != '\n')
+				{
+					text += '\n';
+				}
+			}
+		}
+
+		mFile.write(text.c_str(), text.size());
+	}
+};
+
+LogManager::LogManager() 
+#ifdef BUFFERED_LOGGING
+	: mExiting(false), mLogConsumer()
+#endif
+{
+	auto it = mChannels.begin();
+	std::shared_ptr<LogListener> listener(new FileListener());
+	for (const LogTypeName& name : gTypeNameTable)
+	{
+		it->name = name.mName;
+		it->addListener(listener);
+		it++;
+	}
+	std::shared_ptr<LogListener> TTYListener(new FileListener("TTY",false));
+	getChannel(TTY).addListener(TTYListener);
+#ifdef BUFFERED_LOGGING
+	mLogConsumer = std::thread(&LogManager::consumeLog, this);
+#endif
+}
+
+LogManager::~LogManager()
+{
+#ifdef BUFFERED_LOGGING
+	mExiting = true;
+	mBufferReady.notify_all();
+	mLogConsumer.join();
+}
+
+void LogManager::consumeLog()
+{
+	std::unique_lock<std::mutex> lock(mStatusMut);
+	while (!mExiting)
+	{
+		mBufferReady.wait(lock);
+		mBuffer.lockGet();
+		size_t size = mBuffer.size();
+		std::vector<char> local_messages(size);
+		mBuffer.popN(&local_messages.front(), size);
+		mBuffer.unlockGet();
+
+		u32 cursor = 0;
+		u32 removed = 0;
+		while (cursor < size)
+		{
+			Log::LogMessage msg = Log::LogMessage::deserialize(local_messages.data() + cursor, &removed);
+			cursor += removed;
+			getChannel(msg.mType).log(msg);
+		}
+	}
+#endif
+}
+
+void LogManager::log(LogMessage msg)
+{
+	//don't do any formatting changes or filtering to the TTY output since we
+	//use the raw output to do diffs with the output of a real PS3 and some
+	//programs write text in single bytes to the console
+	if (msg.mType != TTY)
+	{
+		std::string prefix;
+		switch (msg.mServerity)
+		{
+		case Severity::Success:
+			prefix = "S ";
+			break;
+		case Severity::Notice:
+			prefix = "! ";
+			break;
+		case Severity::Warning:
+			prefix = "W ";
+			break;
+		case Severity::Error:
+			prefix = "E ";
+			break;
+		}
+		if (auto thr = get_current_thread_ctrl())
+		{
+			prefix += "{" + thr->get_name() + "} ";
+		}
+		msg.mText.insert(0, prefix);
+		msg.mText.append(1,'\n');
+	}
+#ifdef BUFFERED_LOGGING
+	size_t size = msg.size();
+	std::vector<char> temp_buffer(size);
+	msg.serialize(temp_buffer.data());
+	mBuffer.pushRange(temp_buffer.begin(), temp_buffer.end());
+	mBufferReady.notify_one();
+#else
+	mChannels[static_cast<u32>(msg.mType)].log(msg);
+#endif
+}
+
+void LogManager::addListener(std::shared_ptr<LogListener> listener)
+{
+	for (auto& channel : mChannels)
+	{
+		channel.addListener(listener);
+	}
+}
+
+void LogManager::removeListener(std::shared_ptr<LogListener> listener)
+{
+	for (auto& channel : mChannels)
+	{
+		channel.removeListener(listener);
+	}
+}
+
+LogManager& LogManager::getInstance()
+{
+	if (!g_log_manager)
+	{
+		g_log_manager.reset(new LogManager());
+	}
+
+	return *g_log_manager;
+}
+
+LogChannel &LogManager::getChannel(LogType type)
+{
+	return mChannels[static_cast<u32>(type)];
+}
+
+void log_message(Log::LogType type, Log::Severity sev, const char* text)
+{
+	log_message(type, sev, std::string(text));
+}
+
+void log_message(Log::LogType type, Log::Severity sev, std::string text)
+{
+	if (g_log_manager)
+	{
+		// another msvc bug makes this not work, uncomment this when it's fixed
+		//g_log_manager->log({logType, severity, text});
+		Log::LogMessage msg{ type, sev, std::move(text) };
+		g_log_manager->log(msg);
+	}
+	else
+	{
+		rMessageBox(text,
+			sev == Severity::Notice ? "Notice" :
+			sev == Severity::Warning ? "Warning" :
+			sev == Severity::Success ? "Success" :
+			sev == Severity::Error ? "Error" : "Unknown",
+			sev == Severity::Notice ? rICON_INFORMATION :
+			sev == Severity::Warning ? rICON_EXCLAMATION :
+			sev == Severity::Error ? rICON_ERROR : rICON_INFORMATION);
+	}
+}

Utilities/Log.h

@@ -0,0 +1,135 @@
+#pragma once
+#include "Utilities/MTRingbuffer.h"
+
+//#define BUFFERED_LOGGING 1
+
+//first parameter is of type Log::LogType and text is of type std::string
+
+#define LOG_SUCCESS(logType, text, ...)           log_message(logType, Log::Severity::Success, text, ##__VA_ARGS__)
+#define LOG_NOTICE(logType, text, ...)            log_message(logType, Log::Severity::Notice,  text, ##__VA_ARGS__) 
+#define LOG_WARNING(logType, text, ...)           log_message(logType, Log::Severity::Warning, text, ##__VA_ARGS__) 
+#define LOG_ERROR(logType, text, ...)             log_message(logType, Log::Severity::Error,   text, ##__VA_ARGS__)
+
+namespace Log
+{
+	const unsigned int MAX_LOG_BUFFER_LENGTH = 1024*1024;
+	const unsigned int gBuffSize = 1000;
+
+	enum LogType : u32
+	{
+		GENERAL = 0,
+		LOADER,
+		MEMORY,
+		RSX,
+		HLE,
+		PPU,
+		SPU,
+		ARMv7,
+		TTY,
+	};
+
+
+	struct LogTypeName
+	{
+		LogType mType;
+		std::string mName;
+	};
+
+	//well I'd love make_array() but alas manually counting is not the end of the world
+	static const std::array<LogTypeName, 9> gTypeNameTable = { {
+			{ GENERAL, "G: " },
+			{ LOADER, "LDR: " },
+			{ MEMORY, "MEM: " },
+			{ RSX, "RSX: " },
+			{ HLE, "HLE: " },
+			{ PPU, "PPU: " },
+			{ SPU, "SPU: " },
+			{ ARMv7, "ARM: " },
+			{ TTY, "TTY: " }
+			} };
+
+	enum class Severity : u32
+	{
+		Notice = 0,
+		Warning,
+		Success,
+		Error,
+	};
+
+	struct LogMessage
+	{
+		using size_type = u32;
+		LogType mType;
+		Severity mServerity;
+		std::string mText;
+
+		u32 size() const;
+		void serialize(char *output) const;
+		static LogMessage deserialize(char *input, u32* size_out=nullptr);
+	};
+
+	struct LogListener
+	{
+		virtual ~LogListener() {};
+		virtual void log(const LogMessage &msg) = 0;
+	};
+
+	struct LogChannel
+	{
+		LogChannel();
+		LogChannel(const std::string& name);
+		LogChannel(LogChannel& other) = delete;
+		LogChannel& operator = (LogChannel& other) = delete;
+		void log(const LogMessage &msg);
+		void addListener(std::shared_ptr<LogListener> listener);
+		void removeListener(std::shared_ptr<LogListener> listener);
+		std::string name;
+	private:
+		bool mEnabled;
+		Severity mLogLevel;
+		std::mutex mListenerLock;
+		std::set<std::shared_ptr<LogListener>> mListeners;
+	};
+
+	struct LogManager
+	{
+		LogManager();
+		~LogManager();
+		static LogManager& getInstance();
+		LogChannel& getChannel(LogType type);
+		void log(LogMessage msg);
+		void addListener(std::shared_ptr<LogListener> listener);
+		void removeListener(std::shared_ptr<LogListener> listener);
+#ifdef BUFFERED_LOGGING
+		void consumeLog();
+#endif
+	private:
+#ifdef BUFFERED_LOGGING
+		MTRingbuffer<char, MAX_LOG_BUFFER_LENGTH> mBuffer;
+		std::condition_variable mBufferReady;
+		std::mutex mStatusMut;
+		std::atomic<bool> mExiting;
+		std::thread mLogConsumer;
+#endif
+		std::array<LogChannel, std::tuple_size<decltype(gTypeNameTable)>::value> mChannels;
+		//std::array<LogChannel,gTypeNameTable.size()> mChannels; //TODO: use this once Microsoft sorts their shit out
+	};
+}
+
+static struct { inline operator Log::LogType() { return Log::LogType::GENERAL; } } GENERAL;
+static struct { inline operator Log::LogType() { return Log::LogType::LOADER; } } LOADER;
+static struct { inline operator Log::LogType() { return Log::LogType::MEMORY; } } MEMORY;
+static struct { inline operator Log::LogType() { return Log::LogType::RSX; } } RSX;
+static struct { inline operator Log::LogType() { return Log::LogType::HLE; } } HLE;
+static struct { inline operator Log::LogType() { return Log::LogType::PPU; } } PPU;
+static struct { inline operator Log::LogType() { return Log::LogType::SPU; } } SPU;
+static struct { inline operator Log::LogType() { return Log::LogType::ARMv7; } } ARMv7;
+static struct { inline operator Log::LogType() { return Log::LogType::TTY; } } TTY;
+
+void log_message(Log::LogType type, Log::Severity sev, const char* text);
+void log_message(Log::LogType type, Log::Severity sev, std::string text);
+
+template<typename... Args> never_inline void log_message(Log::LogType type, Log::Severity sev, const char* fmt, Args... args)
+{
+	log_message(type, sev, fmt::format(fmt, fmt::do_unveil(args)...));
+}

Utilities/MTProgressDialog.h

@@ -61,7 +61,7 @@ public:
 		Show();
 	}
 
-	__forceinline void Update(const u8 thread_id, const u64 value, const wxString& msg)
+	force_inline void Update(const u8 thread_id, const u64 value, const wxString& msg)
 	{
 		if(thread_id > m_cores) return;
 
@@ -95,4 +95,4 @@ public:
 
 		wxDialog::Close(force);
 	}
-};
+};

Utilities/MTRingbuffer.h

@@ -0,0 +1,155 @@
+#pragma once
+
+//Simple non-resizable FIFO Ringbuffer that can be simultaneously be read from and written to
+//if we ever get to use boost please replace this with boost::circular_buffer, there's no reason
+//why we would have to keep this amateur attempt at such a fundamental data-structure around
+template< typename T, unsigned int MAX_MTRINGBUFFER_BUFFER_SIZE>
+class MTRingbuffer{
+	std::array<T, MAX_MTRINGBUFFER_BUFFER_SIZE> mBuffer;
+	//this is a recursive mutex because the get methods lock it but the only
+	//way to be sure that they do not block is to check the size and the only
+	//way to check the size and use get atomically is to lock this mutex,
+	//so it goes:
+	//lock get mutex-->check size-->call get-->lock get mutex-->unlock get mutex-->return from get-->unlock get mutex
+	std::recursive_mutex mMutGet;
+	std::mutex mMutPut;
+
+	size_t mGet;
+	size_t mPut;
+	size_t moveGet(size_t by = 1){ return (mGet + by) % MAX_MTRINGBUFFER_BUFFER_SIZE; }
+	size_t movePut(size_t by = 1){ return (mPut + by) % MAX_MTRINGBUFFER_BUFFER_SIZE; }
+public:
+	MTRingbuffer() : mGet(0), mPut(0){}
+
+	//blocks until there's something to get, so check "spaceLeft()" if you want to avoid blocking
+	//also lock the get mutex around the spaceLeft() check and the pop if you want to avoid racing
+	T pop()
+	{
+		std::lock_guard<std::recursive_mutex> lock(mMutGet);
+		while (mGet == mPut)
+		{
+			//wait until there's actually something to get
+			//throwing an exception might be better, blocking here is a little awkward
+			std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
+		}
+		size_t ret = mGet;
+		mGet = moveGet();
+		return mBuffer[ret];
+	}
+
+	//blocks if the buffer is full until there's enough room
+	void push(T &putEle)
+	{
+		std::lock_guard<std::mutex> lock(mMutPut);
+		while (movePut() == mGet)
+		{
+			//if this is reached a lot it's time to increase the buffer size
+			//or implement dynamic re-sizing
+			std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
+		}
+		mBuffer[mPut] = std::forward(putEle);
+		mPut = movePut();
+	}
+
+	bool empty()
+	{
+		return mGet == mPut;
+	}
+
+	//returns the amount of free places, this is the amount of actual free spaces-1
+	//since mGet==mPut signals an empty buffer we can't actually use the last free
+	//space, so we shouldn't report it as free.
+	size_t spaceLeft() //apparently free() is a macro definition in msvc in some conditions
+	{
+		if (mGet < mPut)
+		{
+			return mBuffer.size() - (mPut - mGet) - 1;
+		}
+		else if (mGet > mPut)
+		{
+			return mGet - mPut - 1;
+		}
+		else
+		{
+			return mBuffer.size() - 1;
+		}
+	}
+
+	size_t size()
+	{
+		//the magic -1 is the same magic 1 that is explained in the spaceLeft() function
+		return mBuffer.size() - spaceLeft() - 1;
+	}
+
+	//takes random access iterator to T
+	template<typename IteratorType>
+	void pushRange(IteratorType from, IteratorType until)
+	{
+		std::lock_guard<std::mutex> lock(mMutPut);
+		size_t length = until - from;
+
+		//if whatever we're trying to store is greater than the entire buffer the following loop will be infinite
+		assert(mBuffer.size() > length);
+		while (spaceLeft() < length)
+		{
+			//if this is reached a lot it's time to increase the buffer size
+			//or implement dynamic re-sizing
+			std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
+		}
+		if (mPut + length <= mBuffer.size())
+		{
+			std::copy(from, until, mBuffer.begin() + mPut);
+		}
+		else
+		{
+			size_t tillEnd = mBuffer.size() - mPut;
+			std::copy(from, from + tillEnd, mBuffer.begin() + mPut);
+			std::copy(from + tillEnd, until, mBuffer.begin());
+		}
+		mPut = movePut(length);
+
+	}
+
+	//takes output iterator to T
+	template<typename IteratorType>
+	void popN(IteratorType output, size_t n)
+	{
+		std::lock_guard<std::recursive_mutex> lock(mMutGet);
+		//make sure we're not trying to retrieve more than is in
+		assert(n <= size());
+		peekN<IteratorType>(output, n);
+		mGet = moveGet(n);
+	}
+
+	//takes output iterator to T
+	template<typename IteratorType>
+	void peekN(IteratorType output, size_t n)
+	{
+		size_t lGet = mGet;
+		if (lGet + n <= mBuffer.size())
+		{
+			std::copy_n(mBuffer.begin() + lGet, n, output);
+		}
+		else
+		{
+			auto next = std::copy(mBuffer.begin() + lGet, mBuffer.end(), output);
+			std::copy_n(mBuffer.begin(), n - (mBuffer.size() - lGet), next);
+		}
+	}
+
+	//well this is just asking for trouble
+	//but the comment above the declaration of mMutGet explains why it's there
+	//if there's a better way please remove this
+	void lockGet()
+	{
+		mMutGet.lock();
+	}
+
+	//well this is just asking for trouble
+	//but the comment above the declaration of mMutGet explains why it's there
+	//if there's a better way please remove this
+	void unlockGet()
+	{
+		mMutGet.unlock();
+	}
+};

Utilities/Semaphore.cpp

@@ -0,0 +1,120 @@
+#include "stdafx.h"
+#include "Utilities/Semaphore.h"
+
+bool semaphore_t::try_wait()
+{
+	// check m_value without interlocked op
+	if (m_var.load().value == 0)
+	{
+		return false;
+	}
+
+	// try to decrement m_value atomically
+	const auto old = m_var.atomic_op([](sync_var_t& var)
+	{
+		if (var.value)
+		{
+			var.value--;
+		}
+	});
+
+	// recheck atomic result
+	if (old.value == 0)
+	{
+		return false;
+	}
+
+	return true;
+}
+
+bool semaphore_t::try_post()
+{
+	// check m_value without interlocked op
+	if (m_var.load().value >= max_value)
+	{
+		return false;
+	}
+
+	// try to increment m_value atomically
+	const auto old = m_var.atomic_op([&](sync_var_t& var)
+	{
+		if (var.value < max_value)
+		{
+			var.value++;
+		}
+	});
+
+	// recheck atomic result
+	if (old.value >= max_value)
+	{
+		return false;
+	}
+
+	if (old.waiters)
+	{
+		// notify waiting thread
+		std::lock_guard<std::mutex> lock(m_mutex);
+
+		m_cv.notify_one();
+	}
+
+	return true;
+}
+
+void semaphore_t::wait()
+{
+	if (m_var.atomic_op([](sync_var_t& var) -> bool
+	{
+		if (var.value)
+		{
+			var.value--;
+
+			return true;
+		}
+		else
+		{
+			//var.waiters++;
+
+			return false;
+		}
+	}))
+	{
+		return;
+	}
+
+	std::unique_lock<std::mutex> lock(m_mutex);
+
+	m_var.atomic_op([](sync_var_t& var)
+	{
+		var.waiters++;
+	});
+
+	while (!m_var.atomic_op([](sync_var_t& var) -> bool
+	{
+		if (var.value)
+		{
+			var.value--;
+			var.waiters--;
+
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}))
+	{
+		m_cv.wait(lock);
+	}
+}
+
+bool semaphore_t::post_and_wait()
+{
+	// TODO: merge these functions? Probably has a race condition.
+	if (try_wait()) return false;
+
+	try_post();
+	wait();
+
+	return true;
+}

Utilities/Semaphore.h

@@ -0,0 +1,37 @@
+#pragma once
+
+class semaphore_t
+{
+	// semaphore mutex
+	std::mutex m_mutex;
+
+	// semaphore condition variable
+	std::condition_variable m_cv;
+
+	struct sync_var_t
+	{
+		u32 value; // current semaphore value
+		u32 waiters; // current amount of waiters
+	};
+
+	// current semaphore value
+	atomic_t<sync_var_t> m_var;
+
+public:
+	// max semaphore value
+	const u32 max_value;
+
+	semaphore_t(u32 max_value = 1, u32 value = 0)
+		: m_var(sync_var_t{ value, 0 })
+		, max_value(max_value)
+	{
+	}
+
+	bool try_wait();
+
+	bool try_post();
+
+	void wait();
+
+	bool post_and_wait();
+};

Utilities/SharedMutex.cpp

@@ -0,0 +1,152 @@
+#include "stdafx.h"
+#include "SharedMutex.h"
+
+static const u32 MAX_READERS = 0x7fffffff; // 2^31-1
+
+inline bool shared_mutex_t::try_lock_shared()
+{
+	return m_info.atomic_op([](ownership_info_t& info) -> bool
+	{
+		if (info.readers < MAX_READERS && !info.writers && !info.waiting_readers && !info.waiting_writers)
+		{
+			info.readers++;
+			return true;
+		}
+
+		return false;
+	});
+}
+
+void shared_mutex_t::lock_shared()
+{
+	if (!try_lock_shared())
+	{
+		std::unique_lock<std::mutex> lock(m_mutex);
+
+		m_wrcv.wait(lock, WRAP_EXPR(m_info.atomic_op([](ownership_info_t& info) -> bool
+		{
+			if (info.waiting_readers < UINT16_MAX)
+			{
+				info.waiting_readers++;
+				return true;
+			}
+
+			return false;
+		})));
+
+		m_rcv.wait(lock, WRAP_EXPR(m_info.atomic_op([](ownership_info_t& info) -> bool
+		{
+			if (!info.writers && !info.waiting_writers && info.readers < MAX_READERS)
+			{
+				info.readers++;
+				return true;
+			}
+
+			return false;
+		})));
+
+		const auto info = m_info.atomic_op([](ownership_info_t& info)
+		{
+			if (!info.waiting_readers--)
+			{
+				throw EXCEPTION("Invalid value");
+			}
+		});
+
+		if (info.waiting_readers == UINT16_MAX)
+		{
+			m_wrcv.notify_one();
+		}
+	}
+}
+
+void shared_mutex_t::unlock_shared()
+{
+	const auto info = m_info.atomic_op([](ownership_info_t& info)
+	{
+		if (!info.readers--)
+		{
+			throw EXCEPTION("Not locked");
+		}
+	});
+
+	const bool notify_writers = info.readers == 1 && info.writers;
+	const bool notify_readers = info.readers == UINT32_MAX && info.waiting_readers;
+
+	if (notify_writers || notify_readers)
+	{
+		std::lock_guard<std::mutex> lock(m_mutex);
+
+		if (notify_writers) m_wcv.notify_one();
+		if (notify_readers) m_rcv.notify_one();
+	}
+}
+
+inline bool shared_mutex_t::try_lock()
+{
+	return m_info.compare_and_swap_test({ 0, 0, 0, 0 }, { 0, 1, 0, 0 });
+}
+
+void shared_mutex_t::lock()
+{
+	if (!try_lock())
+	{
+		std::unique_lock<std::mutex> lock(m_mutex);
+
+		m_wwcv.wait(lock, WRAP_EXPR(m_info.atomic_op([](ownership_info_t& info) -> bool
+		{
+			if (info.waiting_writers < UINT16_MAX)
+			{
+				info.waiting_writers++;
+				return true;
+			}
+
+			return false;
+		})));
+
+		m_wcv.wait(lock, WRAP_EXPR(m_info.atomic_op([](ownership_info_t& info) -> bool
+		{
+			if (!info.writers)
+			{
+				info.writers++;
+				return true;
+			}
+
+			return false;
+		})));
+
+		m_wcv.wait(lock, WRAP_EXPR(m_info.load().readers == 0));
+
+		const auto info = m_info.atomic_op([](ownership_info_t& info)
+		{
+			if (!info.waiting_writers--)
+			{
+				throw EXCEPTION("Invalid value");
+			}
+		});
+
+		if (info.waiting_writers == UINT16_MAX)
+		{
+			m_wwcv.notify_one();
+		}
+	}
+}
+
+void shared_mutex_t::unlock()
+{
+	const auto info = m_info.atomic_op([](ownership_info_t& info)
+	{
+		if (!info.writers--)
+		{
+			throw EXCEPTION("Not locked");
+		}
+	});
+
+	if (info.waiting_writers || info.waiting_readers)
+	{
+		std::lock_guard<std::mutex> lock(m_mutex);
+
+		if (info.waiting_writers) m_wcv.notify_one();
+		else if (info.waiting_readers) m_rcv.notify_all();
+	}
+}

Utilities/SharedMutex.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <shared_mutex>
+
+// An attempt to create lock-free (in optimistic case) implementation similar to std::shared_mutex;
+// MSVC implementation of std::shared_timed_mutex is not lock-free and thus may be slow, and std::shared_mutex is not available.
+class shared_mutex_t
+{
+	struct ownership_info_t
+	{
+		u32 readers : 31;
+		u32 writers : 1;
+		u16 waiting_readers;
+		u16 waiting_writers;
+	};
+
+	atomic_t<ownership_info_t> m_info{};
+
+	std::mutex m_mutex;
+	
+	std::condition_variable m_rcv;
+	std::condition_variable m_wcv;
+	std::condition_variable m_wrcv;
+	std::condition_variable m_wwcv;
+
+public:
+	shared_mutex_t() = default;
+
+	// Lock in shared mode
+	void lock_shared();
+
+	// Try to lock in shared mode
+	bool try_lock_shared();
+
+	// Unlock in shared mode
+	void unlock_shared();
+
+	// Lock exclusively
+	void lock();
+
+	// Try to lock exclusively
+	bool try_lock();
+
+	// Unlock exclusively
+	void unlock();
+};

Utilities/SleepQueue.cpp

@@ -0,0 +1,55 @@
+#include "stdafx.h"
+#include "Emu/CPU/CPUThread.h"
+
+#include "SleepQueue.h"
+
+void sleep_queue_entry_t::add_entry()
+{
+	m_queue.emplace_back(m_thread.shared_from_this());
+}
+
+void sleep_queue_entry_t::remove_entry()
+{
+	for (auto it = m_queue.begin(); it != m_queue.end(); it++)
+	{
+		if (it->get() == &m_thread)
+		{
+			m_queue.erase(it);
+			return;
+		}
+	}
+}
+
+bool sleep_queue_entry_t::find() const
+{
+	for (auto it = m_queue.begin(); it != m_queue.end(); it++)
+	{
+		if (it->get() == &m_thread)
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+sleep_queue_entry_t::sleep_queue_entry_t(CPUThread& cpu, sleep_queue_t& queue)
+	: m_thread(cpu)
+	, m_queue(queue)
+{
+	add_entry();
+	cpu.sleep();
+}
+
+sleep_queue_entry_t::sleep_queue_entry_t(CPUThread& cpu, sleep_queue_t& queue, const defer_sleep_t&)
+	: m_thread(cpu)
+	, m_queue(queue)
+{
+	cpu.sleep();
+}
+
+sleep_queue_entry_t::~sleep_queue_entry_t()
+{
+	remove_entry();
+	m_thread.awake();
+}

Utilities/SleepQueue.h

@@ -0,0 +1,46 @@
+#pragma once
+
+class CPUThread;
+
+using sleep_queue_t = std::deque<std::shared_ptr<CPUThread>>;
+
+static struct defer_sleep_t {} const defer_sleep{};
+
+// automatic object handling a thread entry in the sleep queue
+class sleep_queue_entry_t final
+{
+	CPUThread& m_thread;
+	sleep_queue_t& m_queue;
+
+	void add_entry();
+	void remove_entry();
+	bool find() const;
+
+public:
+	// add specified thread to the sleep queue
+	sleep_queue_entry_t(CPUThread& cpu, sleep_queue_t& queue);
+
+	// don't add specified thread to the sleep queue
+	sleep_queue_entry_t(CPUThread& cpu, sleep_queue_t& queue, const defer_sleep_t&);
+
+	// removes specified thread from the sleep queue if added
+	~sleep_queue_entry_t();
+
+	// add thread to the sleep queue
+	inline void enter()
+	{
+		add_entry();
+	}
+
+	// remove thread from the sleep queue
+	inline void leave()
+	{
+		remove_entry();
+	}
+
+	// check whether the thread exists in the sleep queue
+	inline explicit operator bool() const
+	{
+		return find();
+	}
+};

Utilities/StrFmt.cpp

@@ -0,0 +1,247 @@
+#include "stdafx.h"
+#pragma warning(push)
+#pragma message("TODO: remove wx dependency: <wx/string.h>")
+#pragma warning(disable : 4996)
+#include <wx/string.h>
+#pragma warning(pop)
+
+std::string v128::to_hex() const
+{
+	return fmt::format("%016llx%016llx", _u64[1], _u64[0]);
+}
+
+std::string v128::to_xyzw() const
+{
+	return fmt::format("x: %g y: %g z: %g w: %g", _f[3], _f[2], _f[1], _f[0]);
+}
+
+std::string fmt::to_hex(u64 value, size_t count)
+{
+	assert(count - 1 < 16);
+	count = std::max<u64>(count, 16 - cntlz64(value) / 4);
+
+	char res[16] = {};
+
+	for (size_t i = count - 1; ~i; i--, value /= 16)
+	{
+		res[i] = "0123456789abcdef"[value % 16];
+	}
+
+	return std::string(res, count);
+}
+
+std::string fmt::to_udec(u64 value)
+{
+	char res[20] = {};
+	size_t first = sizeof(res);
+
+	if (!value)
+	{
+		res[--first] = '0';
+	}
+
+	for (; value; value /= 10)
+	{
+		res[--first] = '0' + (value % 10);
+	}
+
+	return std::string(&res[first], sizeof(res) - first);
+}
+
+std::string fmt::to_sdec(s64 svalue)
+{
+	const bool sign = svalue < 0;
+	u64 value = sign ? -svalue : svalue;
+
+	char res[20] = {};
+	size_t first = sizeof(res);
+
+	if (!value)
+	{
+		res[--first] = '0';
+	}
+
+	for (; value; value /= 10)
+	{
+		res[--first] = '0' + (value % 10);
+	}
+
+	if (sign)
+	{
+		res[--first] = '-';
+	}
+
+	return std::string(&res[first], sizeof(res) - first);
+}
+
+//extern const std::string fmt::placeholder = "???";
+
+std::string fmt::replace_first(const std::string& src, const std::string& from, const std::string& to)
+{
+	auto pos = src.find(from);
+
+	if (pos == std::string::npos)
+	{
+		return src;
+	}
+
+	return (pos ? src.substr(0, pos) + to : to) + std::string(src.c_str() + pos + from.length());
+}
+
+std::string fmt::replace_all(const std::string &src, const std::string& from, const std::string& to)
+{
+	std::string target = src;
+	for (auto pos = target.find(from); pos != std::string::npos; pos = target.find(from, pos + 1))
+	{
+		target = (pos ? target.substr(0, pos) + to : to) + std::string(target.c_str() + pos + from.length());
+		pos += to.length();
+	}
+
+	return target;
+}
+
+//TODO: move this wx Stuff somewhere else
+//convert a wxString to a std::string encoded in utf8
+//CAUTION, only use this to interface with wxWidgets classes
+std::string fmt::ToUTF8(const wxString& right)
+{
+	auto ret = std::string(((const char *)right.utf8_str()));
+	return ret;
+}
+
+//convert a std::string encoded in utf8 to a wxString
+//CAUTION, only use this to interface with wxWidgets classes
+wxString fmt::FromUTF8(const std::string& right)
+{
+	auto ret = wxString::FromUTF8(right.c_str());
+	return ret;
+}
+
+//TODO: remove this after every snippet that uses it is gone
+//WARNING: not fully compatible with CmpNoCase from wxString
+int fmt::CmpNoCase(const std::string& a, const std::string& b)
+{
+	if (a.length() != b.length())
+	{
+		return -1;
+	}
+	else
+	{
+		return std::equal(a.begin(),
+			a.end(),
+			b.begin(),
+			[](const char& a, const char& b){return ::tolower(a) == ::tolower(b); })
+			? 0 : -1;
+	}
+}
+
+//TODO: remove this after every snippet that uses it is gone
+//WARNING: not fully compatible with CmpNoCase from wxString
+void fmt::Replace(std::string &str, const std::string &searchterm, const std::string& replaceterm)
+{
+	size_t cursor = 0;
+	do
+	{
+		cursor = str.find(searchterm, cursor);
+		if (cursor != std::string::npos)
+		{
+			str.replace(cursor, searchterm.size(), replaceterm);
+			cursor += replaceterm.size();
+		}
+		else
+		{
+			break;
+		}
+	} while (true);
+}
+
+std::vector<std::string> fmt::rSplit(const std::string& source, const std::string& delim)
+{
+	std::vector<std::string> ret;
+	size_t cursor = 0;
+	do
+	{
+		size_t prevcurs = cursor;
+		cursor = source.find(delim, cursor);
+		if (cursor != std::string::npos)
+		{
+			ret.push_back(source.substr(prevcurs,cursor-prevcurs));
+			cursor += delim.size();
+		}
+		else
+		{
+			ret.push_back(source.substr(prevcurs));
+			break;
+		}
+	} while (true);
+	return ret;
+}
+
+std::vector<std::string> fmt::split(const std::string& source, std::initializer_list<std::string> separators, bool is_skip_empty)
+{
+	std::vector<std::string> result;
+
+	size_t cursor_begin = 0;
+
+	for (size_t cursor_end = 0; cursor_end < source.length(); ++cursor_end)
+	{
+		for (auto &separator : separators)
+		{
+			if (strncmp(source.c_str() + cursor_end, separator.c_str(), separator.length()) == 0)
+			{
+				std::string candidate = source.substr(cursor_begin, cursor_end - cursor_begin);
+				if (!is_skip_empty || !candidate.empty())
+					result.push_back(candidate);
+
+				cursor_begin = cursor_end + separator.length();
+				cursor_end = cursor_begin - 1;
+				break;
+			}
+		}
+	}
+
+	if (cursor_begin != source.length())
+	{
+		result.push_back(source.substr(cursor_begin));
+	}
+
+	return std::move(result);
+}
+
+std::string fmt::tolower(std::string source)
+{
+	std::transform(source.begin(), source.end(), source.begin(), ::tolower);
+
+	return source;
+}
+
+std::string fmt::toupper(std::string source)
+{
+	std::transform(source.begin(), source.end(), source.begin(), ::toupper);
+
+	return source;
+}
+
+std::string fmt::escape(std::string source)
+{
+	const std::pair<std::string, std::string> escape_list[] =
+	{
+		{ "\\", "\\\\" },
+		{ "\a", "\\a" },
+		{ "\b", "\\b" },
+		{ "\f", "\\f" },
+		{ "\n", "\\n\n" },
+		{ "\r", "\\r" },
+		{ "\t", "\\t" },
+		{ "\v", "\\v" },
+	};
+
+	source = fmt::replace_all(source, escape_list);
+
+	for (char c = 0; c < 32; c++)
+	{
+		if (c != '\n') source = fmt::replace_all(source, std::string(1, c), fmt::format("\\x%02X", c));
+	}
+
+	return source;
+}

Utilities/StrFmt.h

@@ -0,0 +1,354 @@
+#pragma once
+
+class wxString;
+
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+#define snprintf _snprintf
+#endif
+
+namespace fmt
+{
+	//struct empty_t{};
+
+	//extern const std::string placeholder;
+
+	template <typename T>
+	std::string AfterLast(const std::string& source, T searchstr)
+	{
+		size_t search_pos = source.rfind(searchstr);
+		search_pos = search_pos == std::string::npos ? 0 : search_pos;
+		return source.substr(search_pos);
+	}
+
+	template <typename T>
+	std::string BeforeLast(const std::string& source, T searchstr)
+	{
+		size_t search_pos = source.rfind(searchstr);
+		search_pos = search_pos == std::string::npos ? 0 : search_pos;
+		return source.substr(0, search_pos);
+	}
+
+	template <typename T>
+	std::string AfterFirst(const std::string& source, T searchstr)
+	{
+		size_t search_pos = source.find(searchstr);
+		search_pos = search_pos == std::string::npos ? 0 : search_pos;
+		return source.substr(search_pos);
+	}
+
+	template <typename T>
+	std::string BeforeFirst(const std::string& source, T searchstr)
+	{
+		size_t search_pos = source.find(searchstr);
+		search_pos = search_pos == std::string::npos ? 0 : search_pos;
+		return source.substr(0, search_pos);
+	}
+
+	// write `fmt` from `pos` to the first occurence of `fmt::placeholder` to
+	// the stream `os`. Then write `arg` to to the stream. If there's no
+	// `fmt::placeholder` after `pos` everything in `fmt` after pos is written
+	// to `os`. Then `arg` is written to `os` after appending a space character
+	//template<typename T>
+	//empty_t write(const std::string &fmt, std::ostream &os, std::string::size_type &pos, T &&arg)
+	//{
+	//	std::string::size_type ins = fmt.find(placeholder, pos);
+
+	//	if (ins == std::string::npos)
+	//	{
+	//		os.write(fmt.data() + pos, fmt.size() - pos);
+	//		os << ' ' << arg;
+
+	//		pos = fmt.size();
+	//	}
+	//	else
+	//	{
+	//		os.write(fmt.data() + pos, ins - pos);
+	//		os << arg;
+
+	//		pos = ins + placeholder.size();
+	//	}
+	//	return{};
+	//}
+
+	// typesafe version of a sprintf-like function. Returns the printed to
+	// string. To mark positions where the arguments are supposed to be
+	// inserted use `fmt::placeholder`. If there's not enough placeholders
+	// the rest of the arguments are appended at the end, seperated by spaces
+	//template<typename  ... Args>
+	//std::string SFormat(const std::string &fmt, Args&& ... parameters)
+	//{
+	//	std::ostringstream os;
+	//	std::string::size_type pos = 0;
+	//	std::initializer_list<empty_t> { write(fmt, os, pos, parameters)... };
+
+	//	if (!fmt.empty())
+	//	{
+	//		os.write(fmt.data() + pos, fmt.size() - pos);
+	//	}
+
+	//	std::string result = os.str();
+	//	return result;
+	//}
+
+	std::string replace_first(const std::string& src, const std::string& from, const std::string& to);
+	std::string replace_all(const std::string &src, const std::string& from, const std::string& to);
+
+	template<size_t list_size>
+	std::string replace_all(std::string src, const std::pair<std::string, std::string>(&list)[list_size])
+	{
+		for (size_t pos = 0; pos < src.length(); ++pos)
+		{
+			for (size_t i = 0; i < list_size; ++i)
+			{
+				const size_t comp_length = list[i].first.length();
+
+				if (src.length() - pos < comp_length)
+					continue;
+
+				if (src.substr(pos, comp_length) == list[i].first)
+				{
+					src = (pos ? src.substr(0, pos) + list[i].second : list[i].second) + src.substr(pos + comp_length);
+					pos += list[i].second.length() - 1;
+					break;
+				}
+			}
+		}
+
+		return src;
+	}
+
+	template<size_t list_size>
+	std::string replace_all(std::string src, const std::pair<std::string, std::function<std::string()>>(&list)[list_size])
+	{
+		for (size_t pos = 0; pos < src.length(); ++pos)
+		{
+			for (size_t i = 0; i < list_size; ++i)
+			{
+				const size_t comp_length = list[i].first.length();
+
+				if (src.length() - pos < comp_length)
+					continue;
+
+				if (src.substr(pos, comp_length) == list[i].first)
+				{
+					src = (pos ? src.substr(0, pos) + list[i].second() : list[i].second()) + src.substr(pos + comp_length);
+					pos += list[i].second().length() - 1;
+					break;
+				}
+			}
+		}
+
+		return src;
+	}
+
+	std::string to_hex(u64 value, size_t count = 1);
+	std::string to_udec(u64 value);
+	std::string to_sdec(s64 value);
+
+	template<typename T, bool is_enum = std::is_enum<T>::value> struct unveil
+	{
+		using result_type = T;
+
+		force_inline static result_type get_value(const T& arg)
+		{
+			return arg;
+		}
+	};
+
+	template<> struct unveil<char*, false>
+	{
+		using result_type = const char*;
+
+		force_inline static result_type get_value(const char* arg)
+		{
+			return arg;
+		}
+	};
+
+	template<std::size_t N> struct unveil<const char[N], false>
+	{
+		using result_type = const char*;
+
+		force_inline static result_type get_value(const char(&arg)[N])
+		{
+			return arg;
+		}
+	};
+
+	template<> struct unveil<std::string, false>
+	{
+		using result_type = const char*;
+
+		force_inline static result_type get_value(const std::string& arg)
+		{
+			return arg.c_str();
+		}
+	};
+
+	template<typename T> struct unveil<T, true>
+	{
+		using result_type = std::underlying_type_t<T>;
+
+		force_inline static result_type get_value(const T& arg)
+		{
+			return static_cast<result_type>(arg);
+		}
+	};
+
+	template<typename T, bool Se> struct unveil<se_t<T, Se>, false>
+	{
+		using result_type = typename unveil<T>::result_type;
+
+		force_inline static result_type get_value(const se_t<T, Se>& arg)
+		{
+			return unveil<T>::get_value(arg);
+		}
+	};
+
+	template<typename T>
+	force_inline typename unveil<T>::result_type do_unveil(const T& arg)
+	{
+		return unveil<T>::get_value(arg);
+	}
+
+	// Formatting function with special functionality:
+	//
+	// std::string is forced to .c_str()
+	// be_t<> is forced to .value() (fmt::do_unveil reverts byte order automatically)
+	//
+	// External specializations for fmt::do_unveil (can be found in another headers):
+	// vm::ptr, vm::bptr, ... (fmt::do_unveil) (vm_ptr.h) (with appropriate address type, using .addr() can be avoided)
+	// vm::ref, vm::bref, ... (fmt::do_unveil) (vm_ref.h)
+	//
+	template<typename... Args> safe_buffers std::string format(const char* fmt, Args... args)
+	{
+		// fixed stack buffer for the first attempt
+		std::array<char, 4096> fixed_buf;
+
+		// possibly dynamically allocated buffer for the second attempt
+		std::unique_ptr<char[]> buf;
+
+		// pointer to the current buffer
+		char* buf_addr = fixed_buf.data();
+
+		for (std::size_t buf_size = fixed_buf.size();;)
+		{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat-security"
+			const std::size_t len = std::snprintf(buf_addr, buf_size, fmt, do_unveil(args)...);
+
+#pragma GCC diagnostic pop
+
+			if (len > INT_MAX)
+			{
+				throw std::runtime_error("std::snprintf() failed");
+			}
+
+			if (len < buf_size)
+			{
+				return{ buf_addr, len };
+			}
+
+			buf.reset(buf_addr = new char[buf_size = len + 1]);
+		}
+	}
+
+	struct exception : public std::exception
+	{
+		std::unique_ptr<char[]> message;
+
+		template<typename... Args> never_inline safe_buffers exception(const char* file, int line, const char* func, const char* text, Args... args) noexcept
+		{
+			const std::string data = format(text, args...) + format("\n(in file %s:%d, in function %s)", file, line, func);
+
+			message.reset(new char[data.size() + 1]);
+
+			std::memcpy(message.get(), data.c_str(), data.size() + 1);
+		}
+
+		exception(const exception& other) noexcept
+		{
+			const std::size_t size = std::strlen(other.message.get());
+
+			message.reset(new char[size + 1]);
+
+			std::memcpy(message.get(), other.message.get(), size + 1);
+		}
+
+		virtual const char* what() const noexcept override
+		{
+			return message.get();
+		}
+	};
+
+	//convert a wxString to a std::string encoded in utf8
+	//CAUTION, only use this to interface with wxWidgets classes
+	std::string ToUTF8(const wxString& right);
+
+	//convert a std::string encoded in utf8 to a wxString
+	//CAUTION, only use this to interface with wxWidgets classes
+	wxString FromUTF8(const std::string& right);
+
+	//TODO: remove this after every snippet that uses it is gone
+	//WARNING: not fully compatible with CmpNoCase from wxString
+	int CmpNoCase(const std::string& a, const std::string& b);
+
+	//TODO: remove this after every snippet that uses it is gone
+	//WARNING: not fully compatible with Replace from wxString
+	void Replace(std::string &str, const std::string &searchterm, const std::string& replaceterm);
+
+	std::vector<std::string> rSplit(const std::string& source, const std::string& delim);
+
+	std::vector<std::string> split(const std::string& source, std::initializer_list<std::string> separators, bool is_skip_empty = true);
+
+	template<typename T>
+	std::string merge(const T& source, const std::string& separator)
+	{
+		if (!source.size())
+		{
+			return{};
+		}
+
+		std::string result;
+
+		auto it = source.begin();
+		auto end = source.end();
+		for (--end; it != end; ++it)
+		{
+			result += *it + separator;
+		}
+
+		return result + source.back();
+	}
+
+	template<typename T>
+	std::string merge(std::initializer_list<T> sources, const std::string& separator)
+	{
+		if (!sources.size())
+		{
+			return{};
+		}
+
+		std::string result;
+		bool first = true;
+
+		for (auto &v : sources)
+		{
+			if (first)
+			{
+				result = fmt::merge(v, separator);
+				first = false;
+			}
+			else
+			{
+				result += separator + fmt::merge(v, separator);
+			}
+		}
+
+		return result;
+	}
+
+	std::string tolower(std::string source);
+	std::string toupper(std::string source);
+	std::string escape(std::string source);
+}

Utilities/Thread.h

@@ -1,221 +1,445 @@
 #pragma once
-#include "Array.h"
-#include <functional>
-#include <thread>
-#include <mutex>
-#include <condition_variable>
 
-class ThreadExec;
+const class thread_ctrl_t* get_current_thread_ctrl();
 
-class ThreadBase
+// named thread control class
+class thread_ctrl_t final
 {
-protected:
-	wxString m_name;
-	bool m_detached;
+	friend class named_thread_t;
+
+	template<typename T> friend void current_thread_register_atexit(T);
+
+	// thread handler
+	std::thread m_thread;
+
+	// name getter
+	const std::function<std::string()> m_name;
+
+	// functions executed at thread exit (temporarily)
+	std::vector<std::function<void()>> m_atexit;
 
 public:
-	wxMutex m_main_mutex;
+	thread_ctrl_t(std::function<std::string()> name)
+		: m_name(std::move(name))
+	{
+	}
 
-protected:
-	ThreadBase(bool detached = true, const wxString& name = "Unknown ThreadBase");
-
-public:
-	ThreadExec* m_executor;
-
-	virtual void Task()=0;
-
-	virtual void Start();
-	virtual void Resume();
-	virtual void Pause();
-	virtual void Stop(bool wait = true);
-
-	virtual bool Wait() const;
-	virtual bool IsRunning() const;
-	virtual bool IsPaused() const;
-	virtual bool IsAlive() const;
-	virtual bool TestDestroy() const;
-	virtual wxString GetThreadName() const;
-	virtual void SetThreadName(const wxString& name);
+	// get thread name
+	std::string get_name() const;
 };
 
-ThreadBase* GetCurrentNamedThread();
-
-class ThreadExec : public wxThread
+// register function at thread exit (temporarily)
+template<typename T> void current_thread_register_atexit(T func)
 {
-	wxCriticalSection m_wait_for_exit;
-	volatile bool m_alive;
+	extern thread_local thread_ctrl_t* g_tls_this_thread;
 
-public:
-	ThreadBase* m_parent;
-
-	ThreadExec(bool detached, ThreadBase* parent)
-		: wxThread(detached ? wxTHREAD_DETACHED : wxTHREAD_JOINABLE)
-		, m_parent(parent)
-		, m_alive(true)
-	{
-		Create();
-		Run();
-	}
-
-	void Stop(bool wait = true)
-	{
-		if(!m_alive) return;
-
-		m_parent = nullptr;
-
-		if(wait)
-		{
-			Delete();
-			//wxCriticalSectionLocker lock(m_wait_for_exit);
-		}
-	}
-
-	ExitCode Entry()
-	{
-		//wxCriticalSectionLocker lock(m_wait_for_exit);
-		m_parent->Task();
-		m_alive = false;
-		if(m_parent) m_parent->m_executor = nullptr;
-		return (ExitCode)0;
-	}
-};
-
-//ThreadBase* GetCurrentThread();
-
-template<typename T> class MTPacketBuffer
-{
-protected:
-	volatile bool m_busy;
-	volatile u32 m_put, m_get;
-	Array<u8> m_buffer;
-	u32 m_max_buffer_size;
-	mutable wxCriticalSection m_cs_main;
-
-	void CheckBusy()
-	{
-		m_busy = m_put >= m_max_buffer_size;
-	}
-
-public:
-	MTPacketBuffer(u32 max_buffer_size)
-		: m_max_buffer_size(max_buffer_size)
-	{
-		Flush();
-	}
-
-	~MTPacketBuffer()
-	{
-		Flush();
-	}
-
-	void Flush()
-	{
-		wxCriticalSectionLocker lock(m_cs_main);
-		m_put = m_get = 0;
-		m_buffer.Clear();
-		m_busy = false;
-	}
-
-private:
-	virtual void _push(const T& v) = 0;
-	virtual T _pop() = 0;
-
-public:
-	void Push(const T& v)
-	{
-		wxCriticalSectionLocker lock(m_cs_main);
-		_push(v);
-	}
-
-	T Pop()
-	{
-		wxCriticalSectionLocker lock(m_cs_main);
-		return _pop();
-	}
-
-	bool HasNewPacket() const { wxCriticalSectionLocker lock(m_cs_main); return m_put != m_get; }
-	bool IsBusy() const { return m_busy; }
-};
-
-static __forceinline bool SemaphorePostAndWait(wxSemaphore& sem)
-{
-	if(sem.TryWait() != wxSEMA_BUSY) return false;
-
-	sem.Post();
-	sem.Wait();
-
-	return true;
+	g_tls_this_thread->m_atexit.emplace_back(func);
 }
 
-/*
-class StepThread : public ThreadBase
+class named_thread_t
 {
-	wxSemaphore m_main_sem;
-	wxSemaphore m_destroy_sem;
-	volatile bool m_exit;
-
-protected:
-	StepThread(const wxString& name = "Unknown StepThread")
-		: ThreadBase(true, name)
-		, m_exit(false)
-	{
-	}
-
-	virtual ~StepThread() throw()
-	{
-	}
-
-private:
-	virtual void Task()
-	{
-		m_exit = false;
-
-		while(!TestDestroy())
-		{
-			m_main_sem.Wait();
-
-			if(TestDestroy() || m_exit) break;
-
-			Step();
-		}
-
-		while(!TestDestroy()) Sleep(0);
-		if(m_destroy_sem.TryWait() != wxSEMA_NO_ERROR) m_destroy_sem.Post();
-	}
-
-	virtual void Step()=0;
+	// pointer to managed resource (shared with actual thread)
+	std::shared_ptr<thread_ctrl_t> m_thread;
 
 public:
-	void DoStep()
+	// thread mutex for external use
+	std::mutex mutex;
+
+	// thread condition variable for external use
+	std::condition_variable cv;
+
+public:
+	// initialize in empty state
+	named_thread_t() = default;
+
+	// create named thread
+	named_thread_t(std::function<std::string()> name, std::function<void()> func);
+
+	// destructor, will terminate if thread is neither joined nor detached
+	virtual ~named_thread_t();
+
+	named_thread_t(const named_thread_t&) = delete;
+
+	named_thread_t& operator =(const named_thread_t&) = delete;
+
+public:
+	// get thread name
+	std::string get_name() const;
+
+	// create named thread (current state must be empty)
+	void start(std::function<std::string()> name, std::function<void()> func);
+
+	// detach thread -> empty state
+	void detach();
+
+	// join thread -> empty state
+	void join();
+
+	// check if not empty
+	bool joinable() const { return m_thread.operator bool(); }
+
+	// check whether it is the current running thread
+	bool is_current() const;
+
+	// get internal thread pointer
+	const thread_ctrl_t* get_thread_ctrl() const { return m_thread.get(); }
+};
+
+class autojoin_thread_t final : private named_thread_t
+{
+public:
+	using named_thread_t::mutex;
+	using named_thread_t::cv;
+
+public:
+	autojoin_thread_t() = delete;
+
+	autojoin_thread_t(std::function<std::string()> name, std::function<void()> func)
 	{
-		if(IsRunning()) m_main_sem.Post();
+		start(std::move(name), std::move(func));
 	}
 
-	void WaitForExit()
+	virtual ~autojoin_thread_t() override
 	{
-		if(TestDestroy()) m_destroy_sem.Wait();
+		join();
 	}
 
-	void WaitForNextStep()
+	using named_thread_t::is_current;
+};
+
+extern const std::function<bool()> SQUEUE_ALWAYS_EXIT;
+extern const std::function<bool()> SQUEUE_NEVER_EXIT;
+
+bool squeue_test_exit();
+
+template<typename T, u32 sq_size = 256>
+class squeue_t
+{
+	struct squeue_sync_var_t
 	{
-		if(!IsRunning()) return;
-
-		while(m_main_sem.TryWait() != wxSEMA_NO_ERROR) Sleep(0);
-	}
-
-	void Exit(bool wait = false)
-	{
-		if(!IsAlive()) return;
-
-		if(m_main_sem.TryWait() != wxSEMA_NO_ERROR)
+		struct
 		{
-			m_exit = true;
-			m_main_sem.Post();
+			u32 position : 31;
+			u32 pop_lock : 1;
+		};
+		struct
+		{
+			u32 count : 31;
+			u32 push_lock : 1;
+		};
+	};
+
+	atomic_t<squeue_sync_var_t> m_sync;
+
+	mutable std::mutex m_rcv_mutex;
+	mutable std::mutex m_wcv_mutex;
+	mutable std::condition_variable m_rcv;
+	mutable std::condition_variable m_wcv;
+
+	T m_data[sq_size];
+
+	enum squeue_sync_var_result : u32
+	{
+		SQSVR_OK = 0,
+		SQSVR_LOCKED = 1,
+		SQSVR_FAILED = 2,
+	};
+
+public:
+	squeue_t()
+		: m_sync(squeue_sync_var_t{})
+	{
+	}
+
+	u32 get_max_size() const
+	{
+		return sq_size;
+	}
+
+	bool is_full() const
+	{
+		return m_sync.load().count == sq_size;
+	}
+
+	bool push(const T& data, const std::function<bool()>& test_exit)
+	{
+		u32 pos = 0;
+
+		while (u32 res = m_sync.atomic_op([&pos](squeue_sync_var_t& sync) -> u32
+		{
+			assert(sync.count <= sq_size);
+			assert(sync.position < sq_size);
+
+			if (sync.push_lock)
+			{
+				return SQSVR_LOCKED;
+			}
+			if (sync.count == sq_size)
+			{
+				return SQSVR_FAILED;
+			}
+
+			sync.push_lock = 1;
+			pos = sync.position + sync.count;
+			return SQSVR_OK;
+		}))
+		{
+			if (res == SQSVR_FAILED && (test_exit() || squeue_test_exit()))
+			{
+				return false;
+			}
+
+			std::unique_lock<std::mutex> wcv_lock(m_wcv_mutex);
+			m_wcv.wait_for(wcv_lock, std::chrono::milliseconds(1));
 		}
 
-		Delete();
+		m_data[pos >= sq_size ? pos - sq_size : pos] = data;
 
-		if(wait) WaitForExit();
+		m_sync.atomic_op([](squeue_sync_var_t& sync)
+		{
+			assert(sync.count <= sq_size);
+			assert(sync.position < sq_size);
+			assert(sync.push_lock);
+			sync.push_lock = 0;
+			sync.count++;
+		});
+
+		m_rcv.notify_one();
+		m_wcv.notify_one();
+		return true;
+	}
+
+	bool push(const T& data, const volatile bool* do_exit)
+	{
+		return push(data, [do_exit](){ return do_exit && *do_exit; });
+	}
+
+	force_inline bool push(const T& data)
+	{
+		return push(data, SQUEUE_NEVER_EXIT);
+	}
+
+	force_inline bool try_push(const T& data)
+	{
+		return push(data, SQUEUE_ALWAYS_EXIT);
+	}
+
+	bool pop(T& data, const std::function<bool()>& test_exit)
+	{
+		u32 pos = 0;
+
+		while (u32 res = m_sync.atomic_op([&pos](squeue_sync_var_t& sync) -> u32
+		{
+			assert(sync.count <= sq_size);
+			assert(sync.position < sq_size);
+
+			if (!sync.count)
+			{
+				return SQSVR_FAILED;
+			}
+			if (sync.pop_lock)
+			{
+				return SQSVR_LOCKED;
+			}
+
+			sync.pop_lock = 1;
+			pos = sync.position;
+			return SQSVR_OK;
+		}))
+		{
+			if (res == SQSVR_FAILED && (test_exit() || squeue_test_exit()))
+			{
+				return false;
+			}
+
+			std::unique_lock<std::mutex> rcv_lock(m_rcv_mutex);
+			m_rcv.wait_for(rcv_lock, std::chrono::milliseconds(1));
+		}
+
+		data = m_data[pos];
+
+		m_sync.atomic_op([](squeue_sync_var_t& sync)
+		{
+			assert(sync.count <= sq_size);
+			assert(sync.position < sq_size);
+			assert(sync.pop_lock);
+			sync.pop_lock = 0;
+			sync.position++;
+			sync.count--;
+			if (sync.position == sq_size)
+			{
+				sync.position = 0;
+			}
+		});
+
+		m_rcv.notify_one();
+		m_wcv.notify_one();
+		return true;
+	}
+
+	bool pop(T& data, const volatile bool* do_exit)
+	{
+		return pop(data, [do_exit](){ return do_exit && *do_exit; });
+	}
+
+	force_inline bool pop(T& data)
+	{
+		return pop(data, SQUEUE_NEVER_EXIT);
+	}
+
+	force_inline bool try_pop(T& data)
+	{
+		return pop(data, SQUEUE_ALWAYS_EXIT);
+	}
+
+	bool peek(T& data, u32 start_pos, const std::function<bool()>& test_exit)
+	{
+		assert(start_pos < sq_size);
+		u32 pos = 0;
+
+		while (u32 res = m_sync.atomic_op([&pos, start_pos](squeue_sync_var_t& sync) -> u32
+		{
+			assert(sync.count <= sq_size);
+			assert(sync.position < sq_size);
+
+			if (sync.count <= start_pos)
+			{
+				return SQSVR_FAILED;
+			}
+			if (sync.pop_lock)
+			{
+				return SQSVR_LOCKED;
+			}
+
+			sync.pop_lock = 1;
+			pos = sync.position + start_pos;
+			return SQSVR_OK;
+		}))
+		{
+			if (res == SQSVR_FAILED && (test_exit() || squeue_test_exit()))
+			{
+				return false;
+			}
+
+			std::unique_lock<std::mutex> rcv_lock(m_rcv_mutex);
+			m_rcv.wait_for(rcv_lock, std::chrono::milliseconds(1));
+		}
+
+		data = m_data[pos >= sq_size ? pos - sq_size : pos];
+
+		m_sync.atomic_op([](squeue_sync_var_t& sync)
+		{
+			assert(sync.count <= sq_size);
+			assert(sync.position < sq_size);
+			assert(sync.pop_lock);
+			sync.pop_lock = 0;
+		});
+
+		m_rcv.notify_one();
+		return true;
+	}
+
+	bool peek(T& data, u32 start_pos, const volatile bool* do_exit)
+	{
+		return peek(data, start_pos, [do_exit](){ return do_exit && *do_exit; });
+	}
+
+	force_inline bool peek(T& data, u32 start_pos = 0)
+	{
+		return peek(data, start_pos, SQUEUE_NEVER_EXIT);
+	}
+
+	force_inline bool try_peek(T& data, u32 start_pos = 0)
+	{
+		return peek(data, start_pos, SQUEUE_ALWAYS_EXIT);
+	}
+
+	class squeue_data_t
+	{
+		T* const m_data;
+		const u32 m_pos;
+		const u32 m_count;
+
+		squeue_data_t(T* data, u32 pos, u32 count)
+			: m_data(data)
+			, m_pos(pos)
+			, m_count(count)
+		{
+		}
+
+	public:
+		T& operator [] (u32 index)
+		{
+			assert(index < m_count);
+			index += m_pos;
+			index = index < sq_size ? index : index - sq_size;
+			return m_data[index];
+		}
+	};
+
+	void process(void(*proc)(squeue_data_t data))
+	{
+		u32 pos, count;
+
+		while (m_sync.atomic_op([&pos, &count](squeue_sync_var_t& sync) -> u32
+		{
+			assert(sync.count <= sq_size);
+			assert(sync.position < sq_size);
+
+			if (sync.pop_lock || sync.push_lock)
+			{
+				return SQSVR_LOCKED;
+			}
+
+			pos = sync.position;
+			count = sync.count;
+			sync.pop_lock = 1;
+			sync.push_lock = 1;
+			return SQSVR_OK;
+		}))
+		{
+			std::unique_lock<std::mutex> rcv_lock(m_rcv_mutex);
+			m_rcv.wait_for(rcv_lock, std::chrono::milliseconds(1));
+		}
+
+		proc(squeue_data_t(m_data, pos, count));
+
+		m_sync.atomic_op([](squeue_sync_var_t& sync)
+		{
+			assert(sync.count <= sq_size);
+			assert(sync.position < sq_size);
+			assert(sync.pop_lock && sync.push_lock);
+			sync.pop_lock = 0;
+			sync.push_lock = 0;
+		});
+
+		m_wcv.notify_one();
+		m_rcv.notify_one();
+	}
+
+	void clear()
+	{
+		while (m_sync.atomic_op([](squeue_sync_var_t& sync) -> u32
+		{
+			assert(sync.count <= sq_size);
+			assert(sync.position < sq_size);
+
+			if (sync.pop_lock || sync.push_lock)
+			{
+				return SQSVR_LOCKED;
+			}
+
+			sync.pop_lock = 1;
+			sync.push_lock = 1;
+			return SQSVR_OK;
+		}))
+		{
+			std::unique_lock<std::mutex> rcv_lock(m_rcv_mutex);
+			m_rcv.wait_for(rcv_lock, std::chrono::milliseconds(1));
+		}
+
+		m_sync.exchange({});
+		m_wcv.notify_one();
+		m_rcv.notify_one();
 	}
 };
-*/

Utilities/Timer.h

@@ -1,47 +1,52 @@
 #pragma once
 
+#include <chrono>
+
 class Timer
 {
 private:
-	bool stopped;
-	double startTimeInMicroSec;
-    double endTimeInMicroSec;
-	LARGE_INTEGER frequency;
-	LARGE_INTEGER startCycle;
-	LARGE_INTEGER endCycle;
+	bool m_stopped;
+	std::chrono::high_resolution_clock::time_point m_start;
+	std::chrono::high_resolution_clock::time_point m_end;
 
 public:
-	Timer()
+	Timer() : m_stopped(false)
 	{
-		QueryPerformanceFrequency(&frequency);
-		startCycle.QuadPart = 0;
-		endCycle.QuadPart = 0;
-		stopped = false;
-		startTimeInMicroSec = 0;
-		endTimeInMicroSec = 0;
 	}
 
 	void Start()
 	{
-		stopped = false;
-		QueryPerformanceCounter(&startCycle);
+		m_stopped = false;
+		m_start = std::chrono::high_resolution_clock::now();
 	}
 
 	void Stop()
 	{
-		stopped = true;
-		QueryPerformanceCounter(&endCycle);
+		m_stopped = true;
+		m_end = std::chrono::high_resolution_clock::now();
 	}
 
-	double GetElapsedTimeInSec(){return GetElapsedTimeInMicroSec() / 1000000.0;}
-    double GetElapsedTimeInMilliSec(){return GetElapsedTimeInMicroSec() / 1000.0;}
-    double GetElapsedTimeInMicroSec()
+	double GetElapsedTimeInSec() const
 	{
-		if(!stopped) QueryPerformanceCounter(&endCycle);
-		
-		startTimeInMicroSec = startCycle.QuadPart * (1000000.0 / frequency.QuadPart);
-		endTimeInMicroSec = endCycle.QuadPart * (1000000.0 / frequency.QuadPart);
-
-		return endTimeInMicroSec - startTimeInMicroSec;
+		return double(GetElapsedTimeInMicroSec()) / 1000000.0;
 	}
-};
+
+	double GetElapsedTimeInMilliSec() const
+	{
+		return double(GetElapsedTimeInMicroSec()) / 1000.0;
+	}
+
+	u64 GetElapsedTimeInMicroSec() const
+	{
+		std::chrono::high_resolution_clock::time_point now = m_stopped ? m_end : std::chrono::high_resolution_clock::now();
+
+		return std::chrono::duration_cast<std::chrono::microseconds>(now - m_start).count();
+	}
+
+	u64 GetElapsedTimeInNanoSec() const
+	{
+		std::chrono::high_resolution_clock::time_point now = m_stopped ? m_end : std::chrono::high_resolution_clock::now();
+
+		return std::chrono::duration_cast<std::chrono::nanoseconds>(now - m_start).count();
+	}
+};

Utilities/VirtualMemory.cpp

@@ -0,0 +1,41 @@
+#include "stdafx.h"
+#include "VirtualMemory.h"
+#ifdef _WIN32
+#include <Windows.h>
+#else
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/types.h>
+#endif
+
+namespace memory_helper
+{
+	void* reserve_memory(size_t size)
+	{
+#ifdef _WIN32
+		return VirtualAlloc(NULL, size, MEM_RESERVE, PAGE_NOACCESS);
+#else
+		return mmap(nullptr, size, PROT_NONE, MAP_ANON | MAP_PRIVATE, -1, 0);
+#endif
+	}
+
+	void commit_page_memory(void* pointer, size_t page_size)
+	{
+#ifdef _WIN32
+		VirtualAlloc((u8*)pointer, page_size, MEM_COMMIT, PAGE_READWRITE);
+#else
+		mprotect((u8*)pointer, page_size, PROT_READ | PROT_WRITE);
+#endif
+	}
+
+	void free_reserved_memory(void* pointer, size_t size)
+	{
+#ifdef _WIN32
+		VirtualFree(pointer, 0, MEM_RELEASE);
+#else
+		munmap(pointer, size);
+#endif
+	}
+}

Utilities/VirtualMemory.h

@@ -0,0 +1,22 @@
+#pragma once
+
+namespace memory_helper
+{
+	/**
+	* Reserve size bytes of virtual memory and returns it.
+	* The memory should be commited before usage.
+	*/
+	void* reserve_memory(size_t size);
+
+	/**
+	* Commit page_size bytes of virtual memory starting at pointer.
+	* That is, bake reserved memory with physical memory.
+	* pointer should belong to a range of reserved memory.
+	*/
+	void commit_page_memory(void* pointer, size_t page_size);
+
+	/**
+	* Free memory alloced via reserve_memory.
+	*/
+	void free_reserved_memory(void* pointer, size_t size);
+}

Utilities/git-version-gen.cmd

@@ -0,0 +1,73 @@
+@echo off
+
+rem // This program is free software: you can redistribute it and/or modify
+rem // it under the terms of the GNU General Public License as published by
+rem // the Free Software Foundation, version 2.0 or later versions.
+
+rem // This program is distributed in the hope that it will be useful,
+rem // but WITHOUT ANY WARRANTY; without even the implied warranty of
+rem // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+rem // GNU General Public License 2.0 for more details.
+
+rem // A copy of the GPL 2.0 should have been included with the program.
+rem // If not, see http://www.gnu.org/licenses/
+
+rem // Official git repository and contact information can be found at
+rem // https://github.com/RPCS3/rpcs3 and http://rpcs3.net/.
+
+setlocal ENABLEDELAYEDEXPANSION
+
+set GIT_VERSION_FILE=%~p0..\rpcs3\git-version.h
+if not defined GIT (
+	set GIT="git"
+)
+call %GIT% describe > NUL 2> NUL
+if errorlevel 1 (
+	echo Git not on path, trying default Msysgit paths
+	set GIT="%ProgramFiles(x86)%\Git\bin\git.exe"
+	call !GIT! describe > NUL 2> NUL
+	if errorlevel 1 (
+		set GIT="%ProgramFiles%\Git\bin\git.exe"
+	)
+)
+
+if exist "%GIT_VERSION_FILE%" (
+	rem // Skip updating the file if RPCS3_GIT_VERSION_NO_UPDATE is 1.
+	findstr /B /C:"#define RPCS3_GIT_VERSION_NO_UPDATE 1" "%GIT_VERSION_FILE%" > NUL
+	if not errorlevel 1 (
+		goto done
+	)
+)
+
+call %GIT% describe --always > NUL 2> NUL
+if errorlevel 1 (
+	echo Unable to update git-version.h, git not found.
+	echo If you don't want to add it to your path, set the GIT environment variable.
+
+	echo // This is a generated file. > "%GIT_VERSION_FILE%"
+	echo. >> "%GIT_VERSION_FILE%"
+	echo #define RPCS3_GIT_VERSION "unknown" >> "%GIT_VERSION_FILE%"
+	echo. >> "%GIT_VERSION_FILE%"
+	echo // If you don't want this file to update/recompile, change to 1. >> "%GIT_VERSION_FILE%"
+	echo #define RPCS3_GIT_VERSION_NO_UPDATE 0 >> "%GIT_VERSION_FILE%"
+	goto done
+)
+
+for /F %%I IN ('call %GIT% describe --always') do set GIT_VERSION=%%I
+
+rem // Don't modify the file if it already has the current version.
+if exist "%GIT_VERSION_FILE%" (
+	findstr /C:"%GIT_VERSION%" "%GIT_VERSION_FILE%" > NUL
+	if not errorlevel 1 (
+		goto done
+	)
+)
+
+echo // This is a generated file. > "%GIT_VERSION_FILE%"
+echo. >> "%GIT_VERSION_FILE%"
+echo #define RPCS3_GIT_VERSION "%GIT_VERSION%" >> "%GIT_VERSION_FILE%"
+echo. >> "%GIT_VERSION_FILE%"
+echo // If you don't want this file to update/recompile, change to 1. >> "%GIT_VERSION_FILE%"
+echo #define RPCS3_GIT_VERSION_NO_UPDATE 0 >> "%GIT_VERSION_FILE%"
+
+:done

Utilities/rMsgBox.cpp

@@ -0,0 +1,38 @@
+#include "stdafx.h"
+#include "restore_new.h"
+#pragma warning(push)
+#pragma message("TODO: remove wx dependency: <wx/msgdlg.h>")
+#pragma warning(disable : 4996)
+#include <wx/msgdlg.h>
+#pragma warning(pop)
+#include "define_new_memleakdetect.h"
+#include "rMsgBox.h"
+
+#ifndef QT_UI
+rMessageDialog::rMessageDialog(void *parent, const std::string& msg, const std::string& title , long style )
+{
+	handle = reinterpret_cast<void*>(new wxMessageDialog(
+		reinterpret_cast<wxWindow*>(parent)
+		, fmt::FromUTF8(msg)
+		, fmt::FromUTF8(title)
+		, style
+		));
+}
+
+rMessageDialog::~rMessageDialog()
+{
+	delete reinterpret_cast<wxMessageDialog*>(handle);
+}
+
+long rMessageDialog::ShowModal()
+{
+	return reinterpret_cast<wxMessageDialog*>(handle)->ShowModal();
+}
+
+long rMessageBox(const std::string& message, const std::string& title, long style)
+{
+	return wxMessageBox(fmt::FromUTF8(message), fmt::FromUTF8(title),style);
+}
+
+#endif
+

Utilities/rMsgBox.h

@@ -0,0 +1,38 @@
+#pragma once
+
+enum MsgBoxParams : unsigned long
+{
+	rYES_DEFAULT      = 0x0,
+	rOK_DEFAULT       = 0x0,
+	rCENTRE           = 0x1,
+	rYES              = 0x2, //res
+	rOK               = 0x4,
+	rNO               = 0x8, //res
+	rCANCEL           = 0x10,
+	rYES_NO           = 0xA,
+	rNO_DEFAULT       = 0x80,
+	rICON_EXCLAMATION = 0x100,
+	rICON_ERROR       = 0x200,
+	rICON_HAND        = 0x200,
+	rICON_QUESTION    = 0x400,
+	rICON_INFORMATION = 0x800,
+	rHELP             = 0x1000,
+	rID_CANCEL        = 0x13ED,
+	rID_YES           = 0x13EF, //resDialog
+	rSTAY_ON_TOP      = 0x8000,
+	rICON_NONE        = 0x40000,
+	rICON_AUTH_NEEDED = 0x80000,
+	rCANCEL_DEFAULT   = 0x80000000,
+};
+
+struct rMessageDialog
+{
+	rMessageDialog(void *parent, const std::string& msg, const std::string& title = "RPCS3", long style = rOK | rCENTRE);
+	rMessageDialog(const rMessageDialog& other) = delete;
+	~rMessageDialog();
+	long ShowModal();
+	void *handle;
+};
+
+long rMessageBox(const std::string& message, const std::string& title,long style);
+

Utilities/rPlatform.cpp

@@ -0,0 +1,61 @@
+#include "stdafx.h"
+#include "restore_new.h"
+#pragma warning(push)
+#pragma message("TODO: remove wx dependency: <wx/image.h>")
+#pragma warning(disable : 4996)
+#include <wx/image.h>
+#pragma warning(pop)
+#include "define_new_memleakdetect.h"
+
+#ifndef _WIN32
+#include <dirent.h>
+#endif
+
+#include "rPlatform.h"
+
+rImage::rImage()
+{
+	handle = static_cast<void*>(new wxImage());
+}
+
+rImage::~rImage()
+{
+	delete static_cast<wxImage*>(handle);
+}
+
+void rImage::Create(int width, int height, void *data, void *alpha)
+{
+	static_cast<wxImage*>(handle)->Create(width, height, static_cast<unsigned char*>(data), static_cast<unsigned char*>(alpha));
+}
+void rImage::SaveFile(const std::string& name, rImageType type)
+{
+	if (type == rBITMAP_TYPE_PNG)
+	{
+		static_cast<wxImage*>(handle)->SaveFile(fmt::FromUTF8(name),wxBITMAP_TYPE_PNG);
+	}
+	else
+	{
+		throw EXCEPTION("unsupported type");
+	}
+}
+
+std::string rPlatform::getConfigDir()
+{
+	static std::string dir = ".";
+	if (dir == ".") {
+#ifdef _WIN32
+		dir = "";
+		//mkdir(dir.c_str());
+#else
+		if (getenv("XDG_CONFIG_HOME") != NULL)
+			dir = getenv("XDG_CONFIG_HOME");
+		else if (getenv("HOME") != NULL)
+			dir = getenv("HOME") + std::string("/.config");
+		else // Just in case
+			dir = "./config";
+		dir = dir + "/rpcs3/";
+		mkdir(dir.c_str(), 0777);
+#endif
+	}
+	return dir;
+}

Utilities/rPlatform.h

@@ -0,0 +1,45 @@
+#pragma once
+
+struct rPlatform
+{
+	static std::string getConfigDir();
+};
+
+/**********************************************************************
+*********** RSX Debugger
+************************************************************************/
+
+struct RSXDebuggerProgram
+{
+	u32 id;
+	u32 vp_id;
+	u32 fp_id;
+	std::string vp_shader;
+	std::string fp_shader;
+	bool modified;
+
+	RSXDebuggerProgram()
+		: modified(false)
+	{
+	}
+};
+
+extern std::vector<RSXDebuggerProgram> m_debug_programs;
+
+/**********************************************************************
+*********** Image stuff
+************************************************************************/
+enum rImageType
+{
+	rBITMAP_TYPE_PNG
+};
+struct rImage
+{
+	rImage();
+	rImage(const rImage &) = delete;
+	~rImage();
+	void Create(int width , int height, void *data, void *alpha);
+	void SaveFile(const std::string& name, rImageType type);
+
+	void *handle;
+};

Utilities/rTime.cpp

@@ -0,0 +1,235 @@
+#include "stdafx.h"
+#include "rTime.h"
+#pragma warning(push)
+#pragma message("TODO: remove wx dependency: <wx/datetime.h>")
+#pragma warning(disable : 4996)
+#include <wx/datetime.h>
+#pragma warning(pop)
+
+std::string rDefaultDateTimeFormat = "%c";
+
+rTimeSpan::rTimeSpan()
+{
+	handle = static_cast<void *>(new wxTimeSpan());
+}
+
+rTimeSpan::~rTimeSpan()
+{
+	delete static_cast<wxTimeSpan*>(handle);
+}
+
+rTimeSpan::rTimeSpan(const rTimeSpan& other)
+
+{
+	handle = static_cast<void *>(new wxTimeSpan(*static_cast<wxTimeSpan*>(other.handle)));
+
+}
+
+rTimeSpan::rTimeSpan(int a, int b , int c, int d)
+{
+	handle = static_cast<void *>(new wxTimeSpan(a,b,c,d));
+}
+
+
+rDateSpan::rDateSpan()
+{
+	handle = static_cast<void *>(new wxDateSpan());
+}
+
+rDateSpan::~rDateSpan()
+{
+	delete static_cast<wxDateSpan*>(handle);
+}
+
+rDateSpan::rDateSpan(const rDateSpan& other)
+{
+	handle = static_cast<void *>(new wxDateSpan(*static_cast<wxDateSpan*>(other.handle)));
+}
+
+rDateSpan::rDateSpan(int a, int b, int c, int d)
+{
+	handle = static_cast<void *>(new wxDateSpan(a,b,c,d));
+}
+
+rDateTime::rDateTime()
+{
+	handle = static_cast<void *>(new wxDateTime());
+}
+
+rDateTime::~rDateTime()
+{
+	delete static_cast<wxDateTime*>(handle);
+}
+
+rDateTime::rDateTime(const rDateTime& other)
+{
+	handle = static_cast<void *>(new wxDateTime(*static_cast<wxDateTime*>(other.handle)));
+}
+
+rDateTime::rDateTime(const time_t& time)
+{
+	handle = static_cast<void *>(new wxDateTime(time));
+}
+
+rDateTime::rDateTime(u16 day, rDateTime::Month month, u16 year, u16 hour, u16 minute, u16 second, u32 millisecond)
+{
+	handle = static_cast<void *>(new wxDateTime(day,(wxDateTime::Month)month,year,hour,minute,second,millisecond));
+}
+
+rDateTime rDateTime::UNow()
+{
+	rDateTime time;
+	delete static_cast<wxDateTime*>(time.handle);
+	time.handle = static_cast<void *>(new wxDateTime(wxDateTime::UNow()));
+
+	return time;
+}
+
+rDateTime rDateTime::FromUTC(bool val) 
+{
+	rDateTime time(*this);
+	void *temp = time.handle;
+	
+	time.handle = static_cast<void *>(new wxDateTime(static_cast<wxDateTime*>(temp)->FromTimezone(wxDateTime::GMT0, val)));
+	delete static_cast<wxDateTime*>(temp);
+
+	return time;
+}
+
+rDateTime rDateTime::ToUTC(bool val)
+{
+	rDateTime time(*this);
+	void *temp = time.handle;
+
+	time.handle = static_cast<void *>(new wxDateTime(static_cast<wxDateTime*>(temp)->ToTimezone(wxDateTime::GMT0, val)));
+	delete static_cast<wxDateTime*>(temp);
+
+	return time;
+}
+
+time_t rDateTime::GetTicks()
+{
+	return static_cast<wxDateTime*>(handle)->GetTicks();
+}
+
+void rDateTime::Add(const rTimeSpan& span)
+{
+	static_cast<wxDateTime*>(handle)->Add(*static_cast<wxTimeSpan*>(span.handle));
+}
+
+void rDateTime::Add(const rDateSpan& span)
+{
+	static_cast<wxDateTime*>(handle)->Add(*static_cast<wxDateSpan*>(span.handle));
+}
+
+wxDateTime::TimeZone convertTZ(rDateTime::rTimeZone tz)
+{
+	switch (tz)
+	{
+	case rDateTime::Local:
+		return wxDateTime::Local;
+	case rDateTime::GMT0:
+		return wxDateTime::GMT0;
+	case rDateTime::UTC:
+		return wxDateTime::UTC;
+	default:
+		throw EXCEPTION("WRONG DATETIME");
+	}
+}
+
+std::string rDateTime::Format(const std::string &format, const rTimeZone &tz) const
+{
+	return fmt::ToUTF8(static_cast<wxDateTime*>(handle)->Format(fmt::FromUTF8(format),convertTZ(tz)));
+}
+
+void rDateTime::ParseDateTime(const char* format)
+{
+	static_cast<wxDateTime*>(handle)->ParseDateTime(format);
+}
+
+u32 rDateTime::GetAsDOS()
+{
+	return static_cast<wxDateTime*>(handle)->GetAsDOS();
+}
+
+rDateTime &rDateTime::SetFromDOS(u32 fromdos)
+{
+	static_cast<wxDateTime*>(handle)->SetFromDOS(fromdos);
+	return *this;
+}
+
+bool rDateTime::IsLeapYear(int year, rDateTime::Calender cal)
+{
+	if (cal == Gregorian)
+	{
+		return wxDateTime::IsLeapYear(year, wxDateTime::Gregorian);
+	}
+	else
+	{
+		return wxDateTime::IsLeapYear(year, wxDateTime::Julian);
+	}
+}
+
+int rDateTime::GetNumberOfDays(rDateTime::Month month, int year, rDateTime::Calender cal)
+{
+	if (cal == Gregorian)
+	{
+		return wxDateTime::GetNumberOfDays(static_cast<wxDateTime::Month>(month), year, wxDateTime::Gregorian);
+	}
+	else
+	{
+		return wxDateTime::GetNumberOfDays(static_cast<wxDateTime::Month>(month), year, wxDateTime::Julian);
+	}
+}
+
+void rDateTime::SetToWeekDay(rDateTime::WeekDay day, int n, rDateTime::Month month, int year)
+{
+	static_cast<wxDateTime*>(handle)->SetToWeekDay(
+		static_cast<wxDateTime::WeekDay>(day)
+		, n
+		, static_cast<wxDateTime::Month>(month)
+		, year
+		);
+}
+
+int rDateTime::GetWeekDay()
+{
+	return static_cast<wxDateTime*>(handle)->GetWeekDay();
+}
+
+u16 rDateTime::GetYear(rDateTime::TZ timezone)
+{
+	return static_cast<wxDateTime*>(handle)->GetYear(convertTZ(timezone));
+}
+
+u16 rDateTime::GetMonth(rDateTime::TZ timezone)
+{
+	return static_cast<wxDateTime*>(handle)->GetMonth(convertTZ(timezone));
+}
+
+u16 rDateTime::GetDay(rDateTime::TZ timezone)
+{
+	return static_cast<wxDateTime*>(handle)->GetDay(convertTZ(timezone));
+}
+
+u16 rDateTime::GetHour(rDateTime::TZ timezone)
+{
+	return static_cast<wxDateTime*>(handle)->GetHour(convertTZ(timezone));
+}
+
+u16 rDateTime::GetMinute(rDateTime::TZ timezone)
+{
+	return static_cast<wxDateTime*>(handle)->GetMinute(convertTZ(timezone));
+}
+
+u16 rDateTime::GetSecond(rDateTime::TZ timezone)
+{
+	return static_cast<wxDateTime*>(handle)->GetSecond(convertTZ(timezone));
+}
+
+u32 rDateTime::GetMillisecond(rDateTime::TZ timezone)
+{
+	return static_cast<wxDateTime*>(handle)->GetMillisecond(convertTZ(timezone));
+}
+
+

Utilities/rTime.h

@@ -0,0 +1,102 @@
+#pragma once
+
+extern std::string rDefaultDateTimeFormat;
+
+
+struct rTimeSpan
+{
+	rTimeSpan();
+	~rTimeSpan();
+	rTimeSpan(const rTimeSpan& other);
+	rTimeSpan(int, int, int, int);
+
+	void *handle;
+};
+
+struct rDateSpan
+{
+	rDateSpan();
+	~rDateSpan();
+	rDateSpan(const rDateSpan& other);
+	rDateSpan(int, int, int, int);
+
+	void *handle;
+};
+
+struct rDateTime
+{
+	enum TZ
+	{
+		Local, GMT0,UTC
+	};
+	enum Calender
+	{
+		Gregorian, Julian
+	};
+
+	using rTimeZone = TZ;
+
+	enum WeekDay
+	{
+		Sun = 0,
+		Mon,
+		Tue,
+		Wed,
+		Thu,
+		Fri,
+		Sat,
+		Inv_WeekDay
+	};
+
+	enum Month {
+		Jan = 0,
+		Feb = 1,
+		Mar = 2,
+		Apr = 3,
+		May = 4,
+		Jun = 5,
+		Jul = 6,
+		Aug = 7,
+		Sep = 8,
+		Oct = 9,
+		Nov = 10,
+		Dec = 11,
+		Inv_Month = 12
+	};
+
+	rDateTime();
+	~rDateTime();
+	rDateTime(const rDateTime& other);
+	rDateTime(const time_t &time);
+	rDateTime(u16 day, rDateTime::Month month, u16 year, u16 hour, u16 minute, u16 second, u32 millisecond);
+
+	static rDateTime UNow();
+	rDateTime FromUTC(bool val);
+	rDateTime ToUTC(bool val);
+	time_t GetTicks();
+	void Add(const rTimeSpan& span);
+	void Add(const rDateSpan& span);
+	void Close();
+	std::string Format(const std::string &format = rDefaultDateTimeFormat, const rTimeZone &tz = Local) const;
+
+	void ParseDateTime(const char* format);
+
+	u32 GetAsDOS();
+	rDateTime &SetFromDOS(u32 fromdos);
+
+	static bool IsLeapYear(int year, rDateTime::Calender cal);
+	static int GetNumberOfDays(rDateTime::Month month, int year, rDateTime::Calender cal);
+	void SetToWeekDay(rDateTime::WeekDay day, int n, rDateTime::Month month, int year);
+	int GetWeekDay();
+	
+	u16 GetYear( rDateTime::TZ timezone);
+	u16 GetMonth(rDateTime::TZ timezone);
+	u16 GetDay(rDateTime::TZ timezone);
+	u16 GetHour(rDateTime::TZ timezone);
+	u16 GetMinute(rDateTime::TZ timezone);
+	u16 GetSecond(rDateTime::TZ timezone);
+	u32 GetMillisecond(rDateTime::TZ timezone);
+
+	void *handle;
+};
+

Utilities/rXml.cpp

@@ -0,0 +1,117 @@
+#include "stdafx.h"
+#include "Utilities/rXml.h"
+#pragma warning(push)
+#pragma message("TODO: remove wx dependency: <wx/xml/xml.h>")
+#pragma warning(disable : 4996)
+#include <wx/xml/xml.h>
+#pragma warning(pop)
+
+rXmlNode::rXmlNode()
+{
+	ownPtr = true;
+	handle = reinterpret_cast<void *>(new wxXmlNode());
+}
+
+rXmlNode::rXmlNode(void *ptr)
+{
+	ownPtr = false;
+	handle = ptr;
+}
+
+rXmlNode::rXmlNode(const rXmlNode& other)
+{
+	ownPtr = true;
+	handle = reinterpret_cast<void *>(new wxXmlNode(*reinterpret_cast<wxXmlNode*>(other.handle)));
+}
+
+rXmlNode &rXmlNode::operator=(const rXmlNode& other)
+{
+	if (ownPtr)
+	{
+		delete reinterpret_cast<wxXmlNode*>(handle);
+	}
+	handle = reinterpret_cast<void *>(new wxXmlNode(*reinterpret_cast<wxXmlNode*>(other.handle)));
+	ownPtr = true;
+	return *this;
+}
+
+rXmlNode::~rXmlNode()
+{
+	if (ownPtr)
+	{
+		delete reinterpret_cast<wxXmlNode*>(handle);
+	}
+}
+
+std::shared_ptr<rXmlNode> rXmlNode::GetChildren()
+{
+	wxXmlNode* result = reinterpret_cast<wxXmlNode*>(handle)->GetChildren();
+	if (result)
+	{
+		return std::make_shared<rXmlNode>(reinterpret_cast<void*>(result));
+	}
+	else
+	{
+		return std::shared_ptr<rXmlNode>(nullptr);
+	}
+}
+
+std::shared_ptr<rXmlNode> rXmlNode::GetNext()
+{
+	wxXmlNode* result = reinterpret_cast<wxXmlNode*>(handle)->GetNext();
+	if (result)
+	{
+		return std::make_shared<rXmlNode>(reinterpret_cast<void*>(result));
+	}
+	else
+	{
+		return std::shared_ptr<rXmlNode>(nullptr);
+	}
+}
+
+std::string rXmlNode::GetName()
+{
+	return fmt::ToUTF8(reinterpret_cast<wxXmlNode*>(handle)->GetName());
+}
+
+std::string rXmlNode::GetAttribute(const std::string &name)
+{
+	return fmt::ToUTF8(reinterpret_cast<wxXmlNode*>(handle)->GetAttribute(fmt::FromUTF8(name)));
+}
+
+std::string rXmlNode::GetNodeContent()
+{
+	return fmt::ToUTF8(reinterpret_cast<wxXmlNode*>(handle)->GetNodeContent());
+}
+
+rXmlDocument::rXmlDocument()
+{
+	handle = reinterpret_cast<void *>(new wxXmlDocument());
+}
+
+rXmlDocument::rXmlDocument(const rXmlDocument& other)
+{
+	handle = reinterpret_cast<void *>(new wxXmlDocument(*reinterpret_cast<wxXmlDocument*>(other.handle)));
+}
+
+rXmlDocument &rXmlDocument::operator = (const rXmlDocument& other)
+{
+	delete reinterpret_cast<wxXmlDocument*>(handle);
+	handle = reinterpret_cast<void *>(new wxXmlDocument(*reinterpret_cast<wxXmlDocument*>(other.handle)));
+	return *this;
+}
+
+rXmlDocument::~rXmlDocument()
+{
+	delete reinterpret_cast<wxXmlDocument*>(handle);
+}
+
+void rXmlDocument::Load(const std::string & path)
+{
+	reinterpret_cast<wxXmlDocument*>(handle)->Load(fmt::FromUTF8(path));
+}
+
+std::shared_ptr<rXmlNode> rXmlDocument::GetRoot()
+{
+	return std::make_shared<rXmlNode>(reinterpret_cast<void*>(reinterpret_cast<wxXmlDocument*>(handle)->GetRoot()));
+}

Utilities/rXml.h

@@ -0,0 +1,30 @@
+#pragma once
+
+struct rXmlNode
+{
+	rXmlNode();
+	rXmlNode(void *);
+	rXmlNode(const rXmlNode& other);
+	rXmlNode &operator=(const rXmlNode& other);
+	~rXmlNode();
+	std::shared_ptr<rXmlNode> GetChildren();
+	std::shared_ptr<rXmlNode> GetNext();
+	std::string GetName();
+	std::string GetAttribute( const std::string &name);
+	std::string GetNodeContent();
+
+	void *handle;
+	bool ownPtr;
+};
+
+struct rXmlDocument
+{
+	rXmlDocument();
+	rXmlDocument(const rXmlDocument& other);
+	rXmlDocument &operator=(const rXmlDocument& other);
+	~rXmlDocument();
+	void Load(const std::string & path);
+	std::shared_ptr<rXmlNode> GetRoot();
+
+	void *handle;
+};

Utilities/simpleini/ConvertUTF.c

@@ -0,0 +1,539 @@
+/*
+ * Copyright 2001-2004 Unicode, Inc.
+ * 
+ * Disclaimer
+ * 
+ * This source code is provided as is by Unicode, Inc. No claims are
+ * made as to fitness for any particular purpose. No warranties of any
+ * kind are expressed or implied. The recipient agrees to determine
+ * applicability of information provided. If this file has been
+ * purchased on magnetic or optical media from Unicode, Inc., the
+ * sole remedy for any claim will be exchange of defective media
+ * within 90 days of receipt.
+ * 
+ * Limitations on Rights to Redistribute This Code
+ * 
+ * Unicode, Inc. hereby grants the right to freely use the information
+ * supplied in this file in the creation of products supporting the
+ * Unicode Standard, and to make copies of this file in any form
+ * for internal or external distribution as long as this notice
+ * remains attached.
+ */
+
+/* ---------------------------------------------------------------------
+
+    Conversions between UTF32, UTF-16, and UTF-8. Source code file.
+    Author: Mark E. Davis, 1994.
+    Rev History: Rick McGowan, fixes & updates May 2001.
+    Sept 2001: fixed const & error conditions per
+	mods suggested by S. Parent & A. Lillich.
+    June 2002: Tim Dodd added detection and handling of incomplete
+	source sequences, enhanced error detection, added casts
+	to eliminate compiler warnings.
+    July 2003: slight mods to back out aggressive FFFE detection.
+    Jan 2004: updated switches in from-UTF8 conversions.
+    Oct 2004: updated to use UNI_MAX_LEGAL_UTF32 in UTF-32 conversions.
+
+    See the header file "ConvertUTF.h" for complete documentation.
+
+------------------------------------------------------------------------ */
+
+
+#include "ConvertUTF.h"
+#ifdef CVTUTF_DEBUG
+#include <stdio.h>
+#endif
+
+static const int halfShift  = 10; /* used for shifting by 10 bits */
+
+static const UTF32 halfBase = 0x0010000UL;
+static const UTF32 halfMask = 0x3FFUL;
+
+#define UNI_SUR_HIGH_START  (UTF32)0xD800
+#define UNI_SUR_HIGH_END    (UTF32)0xDBFF
+#define UNI_SUR_LOW_START   (UTF32)0xDC00
+#define UNI_SUR_LOW_END     (UTF32)0xDFFF
+#define false	   0
+#define true	    1
+
+/* --------------------------------------------------------------------- */
+
+ConversionResult ConvertUTF32toUTF16 (
+	const UTF32** sourceStart, const UTF32* sourceEnd, 
+	UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) {
+    ConversionResult result = conversionOK;
+    const UTF32* source = *sourceStart;
+    UTF16* target = *targetStart;
+    while (source < sourceEnd) {
+	UTF32 ch;
+	if (target >= targetEnd) {
+	    result = targetExhausted; break;
+	}
+	ch = *source++;
+	if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
+	    /* UTF-16 surrogate values are illegal in UTF-32; 0xffff or 0xfffe are both reserved values */
+	    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
+		if (flags == strictConversion) {
+		    --source; /* return to the illegal value itself */
+		    result = sourceIllegal;
+		    break;
+		} else {
+		    *target++ = UNI_REPLACEMENT_CHAR;
+		}
+	    } else {
+		*target++ = (UTF16)ch; /* normal case */
+	    }
+	} else if (ch > UNI_MAX_LEGAL_UTF32) {
+	    if (flags == strictConversion) {
+		result = sourceIllegal;
+	    } else {
+		*target++ = UNI_REPLACEMENT_CHAR;
+	    }
+	} else {
+	    /* target is a character in range 0xFFFF - 0x10FFFF. */
+	    if (target + 1 >= targetEnd) {
+		--source; /* Back up source pointer! */
+		result = targetExhausted; break;
+	    }
+	    ch -= halfBase;
+	    *target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
+	    *target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
+	}
+    }
+    *sourceStart = source;
+    *targetStart = target;
+    return result;
+}
+
+/* --------------------------------------------------------------------- */
+
+ConversionResult ConvertUTF16toUTF32 (
+	const UTF16** sourceStart, const UTF16* sourceEnd, 
+	UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) {
+    ConversionResult result = conversionOK;
+    const UTF16* source = *sourceStart;
+    UTF32* target = *targetStart;
+    UTF32 ch, ch2;
+    while (source < sourceEnd) {
+	const UTF16* oldSource = source; /*  In case we have to back up because of target overflow. */
+	ch = *source++;
+	/* If we have a surrogate pair, convert to UTF32 first. */
+	if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
+	    /* If the 16 bits following the high surrogate are in the source buffer... */
+	    if (source < sourceEnd) {
+		ch2 = *source;
+		/* If it's a low surrogate, convert to UTF32. */
+		if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
+		    ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
+			+ (ch2 - UNI_SUR_LOW_START) + halfBase;
+		    ++source;
+		} else if (flags == strictConversion) { /* it's an unpaired high surrogate */
+		    --source; /* return to the illegal value itself */
+		    result = sourceIllegal;
+		    break;
+		}
+	    } else { /* We don't have the 16 bits following the high surrogate. */
+		--source; /* return to the high surrogate */
+		result = sourceExhausted;
+		break;
+	    }
+	} else if (flags == strictConversion) {
+	    /* UTF-16 surrogate values are illegal in UTF-32 */
+	    if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
+		--source; /* return to the illegal value itself */
+		result = sourceIllegal;
+		break;
+	    }
+	}
+	if (target >= targetEnd) {
+	    source = oldSource; /* Back up source pointer! */
+	    result = targetExhausted; break;
+	}
+	*target++ = ch;
+    }
+    *sourceStart = source;
+    *targetStart = target;
+#ifdef CVTUTF_DEBUG
+if (result == sourceIllegal) {
+    fprintf(stderr, "ConvertUTF16toUTF32 illegal seq 0x%04x,%04x\n", ch, ch2);
+    fflush(stderr);
+}
+#endif
+    return result;
+}
+
+/* --------------------------------------------------------------------- */
+
+/*
+ * Index into the table below with the first byte of a UTF-8 sequence to
+ * get the number of trailing bytes that are supposed to follow it.
+ * Note that *legal* UTF-8 values can't have 4 or 5-bytes. The table is
+ * left as-is for anyone who may want to do such conversion, which was
+ * allowed in earlier algorithms.
+ */
+static const char trailingBytesForUTF8[256] = {
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+    2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
+};
+
+/*
+ * Magic values subtracted from a buffer value during UTF8 conversion.
+ * This table contains as many values as there might be trailing bytes
+ * in a UTF-8 sequence.
+ */
+static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL, 
+		     0x03C82080UL, 0xFA082080UL, 0x82082080UL };
+
+/*
+ * Once the bits are split out into bytes of UTF-8, this is a mask OR-ed
+ * into the first byte, depending on how many bytes follow.  There are
+ * as many entries in this table as there are UTF-8 sequence types.
+ * (I.e., one byte sequence, two byte... etc.). Remember that sequencs
+ * for *legal* UTF-8 will be 4 or fewer bytes total.
+ */
+static const UTF8 firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
+
+/* --------------------------------------------------------------------- */
+
+/* The interface converts a whole buffer to avoid function-call overhead.
+ * Constants have been gathered. Loops & conditionals have been removed as
+ * much as possible for efficiency, in favor of drop-through switches.
+ * (See "Note A" at the bottom of the file for equivalent code.)
+ * If your compiler supports it, the "isLegalUTF8" call can be turned
+ * into an inline function.
+ */
+
+/* --------------------------------------------------------------------- */
+
+ConversionResult ConvertUTF16toUTF8 (
+	const UTF16** sourceStart, const UTF16* sourceEnd, 
+	UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
+    ConversionResult result = conversionOK;
+    const UTF16* source = *sourceStart;
+    UTF8* target = *targetStart;
+    while (source < sourceEnd) {
+	UTF32 ch;
+	unsigned short bytesToWrite = 0;
+	const UTF32 byteMask = 0xBF;
+	const UTF32 byteMark = 0x80; 
+	const UTF16* oldSource = source; /* In case we have to back up because of target overflow. */
+	ch = *source++;
+	/* If we have a surrogate pair, convert to UTF32 first. */
+	if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) {
+	    /* If the 16 bits following the high surrogate are in the source buffer... */
+	    if (source < sourceEnd) {
+		UTF32 ch2 = *source;
+		/* If it's a low surrogate, convert to UTF32. */
+		if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) {
+		    ch = ((ch - UNI_SUR_HIGH_START) << halfShift)
+			+ (ch2 - UNI_SUR_LOW_START) + halfBase;
+		    ++source;
+		} else if (flags == strictConversion) { /* it's an unpaired high surrogate */
+		    --source; /* return to the illegal value itself */
+		    result = sourceIllegal;
+		    break;
+		}
+	    } else { /* We don't have the 16 bits following the high surrogate. */
+		--source; /* return to the high surrogate */
+		result = sourceExhausted;
+		break;
+	    }
+	} else if (flags == strictConversion) {
+	    /* UTF-16 surrogate values are illegal in UTF-32 */
+	    if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) {
+		--source; /* return to the illegal value itself */
+		result = sourceIllegal;
+		break;
+	    }
+	}
+	/* Figure out how many bytes the result will require */
+	if (ch < (UTF32)0x80) {	     bytesToWrite = 1;
+	} else if (ch < (UTF32)0x800) {     bytesToWrite = 2;
+	} else if (ch < (UTF32)0x10000) {   bytesToWrite = 3;
+	} else if (ch < (UTF32)0x110000) {  bytesToWrite = 4;
+	} else {			    bytesToWrite = 3;
+					    ch = UNI_REPLACEMENT_CHAR;
+	}
+
+	target += bytesToWrite;
+	if (target > targetEnd) {
+	    source = oldSource; /* Back up source pointer! */
+	    target -= bytesToWrite; result = targetExhausted; break;
+	}
+	switch (bytesToWrite) { /* note: everything falls through. */
+	    case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
+	    case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
+	    case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
+	    case 1: *--target =  (UTF8)(ch | firstByteMark[bytesToWrite]);
+	}
+	target += bytesToWrite;
+    }
+    *sourceStart = source;
+    *targetStart = target;
+    return result;
+}
+
+/* --------------------------------------------------------------------- */
+
+/*
+ * Utility routine to tell whether a sequence of bytes is legal UTF-8.
+ * This must be called with the length pre-determined by the first byte.
+ * If not calling this from ConvertUTF8to*, then the length can be set by:
+ *  length = trailingBytesForUTF8[*source]+1;
+ * and the sequence is illegal right away if there aren't that many bytes
+ * available.
+ * If presented with a length > 4, this returns false.  The Unicode
+ * definition of UTF-8 goes up to 4-byte sequences.
+ */
+
+static Boolean isLegalUTF8(const UTF8 *source, int length) {
+    UTF8 a;
+    const UTF8 *srcptr = source+length;
+    switch (length) {
+    default: return false;
+	/* Everything else falls through when "true"... */
+    case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
+    case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
+    case 2: if ((a = (*--srcptr)) > 0xBF) return false;
+
+	switch (*source) {
+	    /* no fall-through in this inner switch */
+	    case 0xE0: if (a < 0xA0) return false; break;
+	    case 0xED: if (a > 0x9F) return false; break;
+	    case 0xF0: if (a < 0x90) return false; break;
+	    case 0xF4: if (a > 0x8F) return false; break;
+	    default:   if (a < 0x80) return false;
+	}
+
+    case 1: if (*source >= 0x80 && *source < 0xC2) return false;
+    }
+    if (*source > 0xF4) return false;
+    return true;
+}
+
+/* --------------------------------------------------------------------- */
+
+/*
+ * Exported function to return whether a UTF-8 sequence is legal or not.
+ * This is not used here; it's just exported.
+ */
+Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd) {
+    int length = trailingBytesForUTF8[*source]+1;
+    if (source+length > sourceEnd) {
+	return false;
+    }
+    return isLegalUTF8(source, length);
+}
+
+/* --------------------------------------------------------------------- */
+
+ConversionResult ConvertUTF8toUTF16 (
+	const UTF8** sourceStart, const UTF8* sourceEnd, 
+	UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) {
+    ConversionResult result = conversionOK;
+    const UTF8* source = *sourceStart;
+    UTF16* target = *targetStart;
+    while (source < sourceEnd) {
+	UTF32 ch = 0;
+	unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
+	if (source + extraBytesToRead >= sourceEnd) {
+	    result = sourceExhausted; break;
+	}
+	/* Do this check whether lenient or strict */
+	if (! isLegalUTF8(source, extraBytesToRead+1)) {
+	    result = sourceIllegal;
+	    break;
+	}
+	/*
+	 * The cases all fall through. See "Note A" below.
+	 */
+	switch (extraBytesToRead) {
+	    case 5: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */
+	    case 4: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */
+	    case 3: ch += *source++; ch <<= 6;
+	    case 2: ch += *source++; ch <<= 6;
+	    case 1: ch += *source++; ch <<= 6;
+	    case 0: ch += *source++;
+	}
+	ch -= offsetsFromUTF8[extraBytesToRead];
+
+	if (target >= targetEnd) {
+	    source -= (extraBytesToRead+1); /* Back up source pointer! */
+	    result = targetExhausted; break;
+	}
+	if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */
+	    /* UTF-16 surrogate values are illegal in UTF-32 */
+	    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
+		if (flags == strictConversion) {
+		    source -= (extraBytesToRead+1); /* return to the illegal value itself */
+		    result = sourceIllegal;
+		    break;
+		} else {
+		    *target++ = UNI_REPLACEMENT_CHAR;
+		}
+	    } else {
+		*target++ = (UTF16)ch; /* normal case */
+	    }
+	} else if (ch > UNI_MAX_UTF16) {
+	    if (flags == strictConversion) {
+		result = sourceIllegal;
+		source -= (extraBytesToRead+1); /* return to the start */
+		break; /* Bail out; shouldn't continue */
+	    } else {
+		*target++ = UNI_REPLACEMENT_CHAR;
+	    }
+	} else {
+	    /* target is a character in range 0xFFFF - 0x10FFFF. */
+	    if (target + 1 >= targetEnd) {
+		source -= (extraBytesToRead+1); /* Back up source pointer! */
+		result = targetExhausted; break;
+	    }
+	    ch -= halfBase;
+	    *target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START);
+	    *target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START);
+	}
+    }
+    *sourceStart = source;
+    *targetStart = target;
+    return result;
+}
+
+/* --------------------------------------------------------------------- */
+
+ConversionResult ConvertUTF32toUTF8 (
+	const UTF32** sourceStart, const UTF32* sourceEnd, 
+	UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) {
+    ConversionResult result = conversionOK;
+    const UTF32* source = *sourceStart;
+    UTF8* target = *targetStart;
+    while (source < sourceEnd) {
+	UTF32 ch;
+	unsigned short bytesToWrite = 0;
+	const UTF32 byteMask = 0xBF;
+	const UTF32 byteMark = 0x80; 
+	ch = *source++;
+	if (flags == strictConversion ) {
+	    /* UTF-16 surrogate values are illegal in UTF-32 */
+	    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
+		--source; /* return to the illegal value itself */
+		result = sourceIllegal;
+		break;
+	    }
+	}
+	/*
+	 * Figure out how many bytes the result will require. Turn any
+	 * illegally large UTF32 things (> Plane 17) into replacement chars.
+	 */
+	if (ch < (UTF32)0x80) {	     bytesToWrite = 1;
+	} else if (ch < (UTF32)0x800) {     bytesToWrite = 2;
+	} else if (ch < (UTF32)0x10000) {   bytesToWrite = 3;
+	} else if (ch <= UNI_MAX_LEGAL_UTF32) {  bytesToWrite = 4;
+	} else {			    bytesToWrite = 3;
+					    ch = UNI_REPLACEMENT_CHAR;
+					    result = sourceIllegal;
+	}
+	
+	target += bytesToWrite;
+	if (target > targetEnd) {
+	    --source; /* Back up source pointer! */
+	    target -= bytesToWrite; result = targetExhausted; break;
+	}
+	switch (bytesToWrite) { /* note: everything falls through. */
+	    case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
+	    case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
+	    case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6;
+	    case 1: *--target = (UTF8) (ch | firstByteMark[bytesToWrite]);
+	}
+	target += bytesToWrite;
+    }
+    *sourceStart = source;
+    *targetStart = target;
+    return result;
+}
+
+/* --------------------------------------------------------------------- */
+
+ConversionResult ConvertUTF8toUTF32 (
+	const UTF8** sourceStart, const UTF8* sourceEnd, 
+	UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) {
+    ConversionResult result = conversionOK;
+    const UTF8* source = *sourceStart;
+    UTF32* target = *targetStart;
+    while (source < sourceEnd) {
+	UTF32 ch = 0;
+	unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
+	if (source + extraBytesToRead >= sourceEnd) {
+	    result = sourceExhausted; break;
+	}
+	/* Do this check whether lenient or strict */
+	if (! isLegalUTF8(source, extraBytesToRead+1)) {
+	    result = sourceIllegal;
+	    break;
+	}
+	/*
+	 * The cases all fall through. See "Note A" below.
+	 */
+	switch (extraBytesToRead) {
+	    case 5: ch += *source++; ch <<= 6;
+	    case 4: ch += *source++; ch <<= 6;
+	    case 3: ch += *source++; ch <<= 6;
+	    case 2: ch += *source++; ch <<= 6;
+	    case 1: ch += *source++; ch <<= 6;
+	    case 0: ch += *source++;
+	}
+	ch -= offsetsFromUTF8[extraBytesToRead];
+
+	if (target >= targetEnd) {
+	    source -= (extraBytesToRead+1); /* Back up the source pointer! */
+	    result = targetExhausted; break;
+	}
+	if (ch <= UNI_MAX_LEGAL_UTF32) {
+	    /*
+	     * UTF-16 surrogate values are illegal in UTF-32, and anything
+	     * over Plane 17 (> 0x10FFFF) is illegal.
+	     */
+	    if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) {
+		if (flags == strictConversion) {
+		    source -= (extraBytesToRead+1); /* return to the illegal value itself */
+		    result = sourceIllegal;
+		    break;
+		} else {
+		    *target++ = UNI_REPLACEMENT_CHAR;
+		}
+	    } else {
+		*target++ = ch;
+	    }
+	} else { /* i.e., ch > UNI_MAX_LEGAL_UTF32 */
+	    result = sourceIllegal;
+	    *target++ = UNI_REPLACEMENT_CHAR;
+	}
+    }
+    *sourceStart = source;
+    *targetStart = target;
+    return result;
+}
+
+/* ---------------------------------------------------------------------
+
+    Note A.
+    The fall-through switches in UTF-8 reading code save a
+    temp variable, some decrements & conditionals.  The switches
+    are equivalent to the following loop:
+	{
+	    int tmpBytesToRead = extraBytesToRead+1;
+	    do {
+		ch += *source++;
+		--tmpBytesToRead;
+		if (tmpBytesToRead) ch <<= 6;
+	    } while (tmpBytesToRead > 0);
+	}
+    In UTF-8 writing code, the switches on "bytesToWrite" are
+    similarly unrolled loops.
+
+   --------------------------------------------------------------------- */

Utilities/simpleini/ConvertUTF.h

@@ -0,0 +1,151 @@
+#pragma once
+
+/*
+ * Copyright 2001-2004 Unicode, Inc.
+ * 
+ * Disclaimer
+ * 
+ * This source code is provided as is by Unicode, Inc. No claims are
+ * made as to fitness for any particular purpose. No warranties of any
+ * kind are expressed or implied. The recipient agrees to determine
+ * applicability of information provided. If this file has been
+ * purchased on magnetic or optical media from Unicode, Inc., the
+ * sole remedy for any claim will be exchange of defective media
+ * within 90 days of receipt.
+ * 
+ * Limitations on Rights to Redistribute This Code
+ * 
+ * Unicode, Inc. hereby grants the right to freely use the information
+ * supplied in this file in the creation of products supporting the
+ * Unicode Standard, and to make copies of this file in any form
+ * for internal or external distribution as long as this notice
+ * remains attached.
+ */
+
+/* ---------------------------------------------------------------------
+
+    Conversions between UTF32, UTF-16, and UTF-8.  Header file.
+
+    Several funtions are included here, forming a complete set of
+    conversions between the three formats.  UTF-7 is not included
+    here, but is handled in a separate source file.
+
+    Each of these routines takes pointers to input buffers and output
+    buffers.  The input buffers are const.
+
+    Each routine converts the text between *sourceStart and sourceEnd,
+    putting the result into the buffer between *targetStart and
+    targetEnd. Note: the end pointers are *after* the last item: e.g. 
+    *(sourceEnd - 1) is the last item.
+
+    The return result indicates whether the conversion was successful,
+    and if not, whether the problem was in the source or target buffers.
+    (Only the first encountered problem is indicated.)
+
+    After the conversion, *sourceStart and *targetStart are both
+    updated to point to the end of last text successfully converted in
+    the respective buffers.
+
+    Input parameters:
+	sourceStart - pointer to a pointer to the source buffer.
+		The contents of this are modified on return so that
+		it points at the next thing to be converted.
+	targetStart - similarly, pointer to pointer to the target buffer.
+	sourceEnd, targetEnd - respectively pointers to the ends of the
+		two buffers, for overflow checking only.
+
+    These conversion functions take a ConversionFlags argument. When this
+    flag is set to strict, both irregular sequences and isolated surrogates
+    will cause an error.  When the flag is set to lenient, both irregular
+    sequences and isolated surrogates are converted.
+
+    Whether the flag is strict or lenient, all illegal sequences will cause
+    an error return. This includes sequences such as: <F4 90 80 80>, <C0 80>,
+    or <A0> in UTF-8, and values above 0x10FFFF in UTF-32. Conformant code
+    must check for illegal sequences.
+
+    When the flag is set to lenient, characters over 0x10FFFF are converted
+    to the replacement character; otherwise (when the flag is set to strict)
+    they constitute an error.
+
+    Output parameters:
+	The value "sourceIllegal" is returned from some routines if the input
+	sequence is malformed.  When "sourceIllegal" is returned, the source
+	value will point to the illegal value that caused the problem. E.g.,
+	in UTF-8 when a sequence is malformed, it points to the start of the
+	malformed sequence.  
+
+    Author: Mark E. Davis, 1994.
+    Rev History: Rick McGowan, fixes & updates May 2001.
+		 Fixes & updates, Sept 2001.
+
+------------------------------------------------------------------------ */
+
+/* ---------------------------------------------------------------------
+    The following 4 definitions are compiler-specific.
+    The C standard does not guarantee that wchar_t has at least
+    16 bits, so wchar_t is no less portable than unsigned short!
+    All should be unsigned values to avoid sign extension during
+    bit mask & shift operations.
+------------------------------------------------------------------------ */
+
+typedef unsigned int	UTF32;	/* at least 32 bits */
+typedef unsigned short	UTF16;	/* at least 16 bits */
+typedef unsigned char	UTF8;	/* typically 8 bits */
+typedef unsigned char	Boolean; /* 0 or 1 */
+
+/* Some fundamental constants */
+#define UNI_REPLACEMENT_CHAR (UTF32)0x0000FFFD
+#define UNI_MAX_BMP (UTF32)0x0000FFFF
+#define UNI_MAX_UTF16 (UTF32)0x0010FFFF
+#define UNI_MAX_UTF32 (UTF32)0x7FFFFFFF
+#define UNI_MAX_LEGAL_UTF32 (UTF32)0x0010FFFF
+
+typedef enum {
+	conversionOK, 		/* conversion successful */
+	sourceExhausted,	/* partial character in source, but hit end */
+	targetExhausted,	/* insuff. room in target for conversion */
+	sourceIllegal		/* source sequence is illegal/malformed */
+} ConversionResult;
+
+typedef enum {
+	strictConversion = 0,
+	lenientConversion
+} ConversionFlags;
+
+/* This is for C++ and does no harm in C */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ConversionResult ConvertUTF8toUTF16 (
+		const UTF8** sourceStart, const UTF8* sourceEnd, 
+		UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
+
+ConversionResult ConvertUTF16toUTF8 (
+		const UTF16** sourceStart, const UTF16* sourceEnd, 
+		UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
+		
+ConversionResult ConvertUTF8toUTF32 (
+		const UTF8** sourceStart, const UTF8* sourceEnd, 
+		UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
+
+ConversionResult ConvertUTF32toUTF8 (
+		const UTF32** sourceStart, const UTF32* sourceEnd, 
+		UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags);
+		
+ConversionResult ConvertUTF16toUTF32 (
+		const UTF16** sourceStart, const UTF16* sourceEnd, 
+		UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags);
+
+ConversionResult ConvertUTF32toUTF16 (
+		const UTF32** sourceStart, const UTF32* sourceEnd, 
+		UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags);
+
+Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd);
+
+#ifdef __cplusplus
+}
+#endif
+
+/* --------------------------------------------------------------------- */

Utilities/simpleini/LICENCE.txt

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2006-2013 Brodie Thiesfield
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Utilities/simpleini/README.md

@@ -0,0 +1,150 @@
+simpleini
+=========
+
+A cross-platform library that provides a simple API to read and write INI-style configuration files. It supports data files in ASCII, MBCS and Unicode. It is designed explicitly to be portable to any platform and has been tested on Windows, WinCE and Linux. Released as open-source and free using the MIT licence.
+
+# Feature Summary
+
+- MIT Licence allows free use in all software (including GPL and commercial)
+- multi-platform (Windows 95/98/ME/NT/2K/XP/2003, Windows CE, Linux, Unix)
+- loading and saving of INI-style configuration files
+- configuration files can have any newline format on all platforms
+- liberal acceptance of file format
+  * key/values with no section
+  * removal of whitespace around sections, keys and values
+- support for multi-line values (values with embedded newline characters)
+- optional support for multiple keys with the same name
+- optional case-insensitive sections and keys (for ASCII characters only)
+- saves files with sections and keys in the same order as they were loaded
+- preserves comments on the file, section and keys where possible.
+- supports both char or wchar_t programming interfaces
+- supports both MBCS (system locale) and UTF-8 file encodings
+- system locale does not need to be UTF-8 on Linux/Unix to load UTF-8 file
+- support for non-ASCII characters in section, keys, values and comments
+- support for non-standard character types or file encodings via user-written converter classes
+- support for adding/modifying values programmatically
+- compiles cleanly in the following compilers:
+  * Windows/VC6 (warning level 3)
+  * Windows/VC.NET 2003 (warning level 4)
+  * Windows/VC 2005 (warning level 4)
+  * Linux/gcc (-Wall)
+  * Windows/MinGW GCC
+
+# Documentation
+
+Full documentation of the interface is available in doxygen format.
+
+# Examples
+
+These snippets are included with the distribution in the file snippets.cpp.
+
+### SIMPLE USAGE
+
+```c++
+CSimpleIniA ini;
+ini.SetUnicode();
+ini.LoadFile("myfile.ini");
+const char * pVal = ini.GetValue("section", "key", "default");
+ini.SetValue("section", "key", "newvalue");
+```
+
+### LOADING DATA
+
+```c++
+// load from a data file
+CSimpleIniA ini(a_bIsUtf8, a_bUseMultiKey, a_bUseMultiLine);
+SI_Error rc = ini.LoadFile(a_pszFile);
+if (rc < 0) return false;
+
+// load from a string
+std::string strData;
+rc = ini.LoadData(strData.c_str(), strData.size());
+if (rc < 0) return false;
+```
+
+### GETTING SECTIONS AND KEYS
+
+```c++
+// get all sections
+CSimpleIniA::TNamesDepend sections;
+ini.GetAllSections(sections);
+
+// get all keys in a section
+CSimpleIniA::TNamesDepend keys;
+ini.GetAllKeys("section-name", keys);
+```
+
+### GETTING VALUES
+
+```c++
+// get the value of a key
+const char * pszValue = ini.GetValue("section-name", 
+    "key-name", NULL /*default*/);
+
+// get the value of a key which may have multiple 
+// values. If bHasMultipleValues is true, then just 
+// one value has been returned
+bool bHasMultipleValues;
+pszValue = ini.GetValue("section-name", "key-name", 
+    NULL /*default*/, &amp;bHasMultipleValues);
+
+// get all values of a key with multiple values
+CSimpleIniA::TNamesDepend values;
+ini.GetAllValues("section-name", "key-name", values);
+
+// sort the values into the original load order
+values.sort(CSimpleIniA::Entry::LoadOrder());
+
+// output all of the items
+CSimpleIniA::TNamesDepend::const_iterator i;
+for (i = values.begin(); i != values.end(); ++i) { 
+    printf("key-name = '%s'\n", i->pItem);
+}
+```
+
+### MODIFYING DATA
+
+```c++
+// adding a new section
+rc = ini.SetValue("new-section", NULL, NULL);
+if (rc < 0) return false;
+printf("section: %s\n", rc == SI_INSERTED ? 
+    "inserted" : "updated");
+
+// adding a new key ("new-section" will be added 
+// automatically if it doesn't already exist)
+rc = ini.SetValue("new-section", "new-key", "value");
+if (rc < 0) return false;
+printf("key: %s\n", rc == SI_INSERTED ? 
+    "inserted" : "updated");
+
+// changing the value of a key
+rc = ini.SetValue("section", "key", "updated-value");
+if (rc < 0) return false;
+printf("key: %s\n", rc == SI_INSERTED ? 
+    "inserted" : "updated");
+```
+
+### DELETING DATA
+
+```c++
+// deleting a key from a section. Optionally the entire
+// section may be deleted if it is now empty.
+ini.Delete("section-name", "key-name", 
+    true /*delete the section if empty*/);
+
+// deleting an entire section and all keys in it
+ini.Delete("section-name", NULL);
+```
+
+### SAVING DATA
+
+```c++
+// save the data to a string
+rc = ini.Save(strData);
+if (rc < 0) return false;
+
+// save the data back to the file
+rc = ini.SaveFile(a_pszFile);
+if (rc < 0) return false;
+```

appveyor.yml

@@ -0,0 +1,35 @@
+version: 1.0.{build}
+os: Visual Studio 2015
+configuration:
+# - Release
+ - ReleaseLLVM
+platform: x64
+clone_folder: c:\rpcs3
+clone_depth: 3
+test: off
+
+branches:
+ except:
+   - ppu_recompiler
+
+before_build:
+ # until git for win 2.5 release with commit checkout
+ - git submodule update --init ffmpeg asmjit minidx9
+ - 7z x wxWidgets.7z -aos -oC:\rpcs3\wxWidgets > null
+ - if %configuration%==Release (cmake -G "Visual Studio 14 Win64")
+   else (7z x llvmlibs.7z -aos -oC:\rpcs3 > null && cmake -G "Visual Studio 14 Win64" -DLLVM_DIR=C:/rpcs3/llvm_build/share/llvm/cmake)
+
+build_script:
+ - cmake --build . --config Release -- /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
+
+install:
+ - ps: Start-FileDownload 'https://402331b94f8e4b87ae2ef4677347f7956cf3861f.googledrive.com/host/0B6v_qtb9hkicfmt0NG0wTTRtUmF4X3VTQk5Oc2JidEVKVnUteDA1dXdrYlNsVW9kREpsSHc/wxWidgets.7z'
+ - ps: Start-FileDownload 'https://402331b94f8e4b87ae2ef4677347f7956cf3861f.googledrive.com/host/0B6v_qtb9hkicfmt0NG0wTTRtUmF4X3VTQk5Oc2JidEVKVnUteDA1dXdrYlNsVW9kREpsSHc/llvmlibs.7z'
+ - set WXWIN=C:\rpcs3\wxWidgets
+ - set OPENALDIR=C:\rpcs3\OpenAL
+ - set PATH=C:\Program Files (x86)\MSBuild\14.0\Bin;C:\wxWidgets;%PATH%
+ - set COMMIT_SHA=%APPVEYOR_REPO_COMMIT:~0,8%
+
+artifacts:
+ - path: bin
+   name: rpcs3-$(configuration)-$(COMMIT_SHA)

asmjitsrc/asmjit.vcxproj

@@ -0,0 +1,136 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\asmjit\src\asmjit\base\assembler.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\codegen.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\compiler.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\constpool.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\containers.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\context.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\cpuinfo.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\cputicks.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\error.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\globals.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\intutil.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\logger.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\operand.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\runtime.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\string.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\vmem.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\zone.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\x86\x86assembler.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\x86\x86compiler.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\x86\x86context.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\x86\x86cpuinfo.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\x86\x86inst.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\x86\x86operand.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\x86\x86operand_regs.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\x86\x86scheduler.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\asmjit\src\asmjit\base\assembler.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\codegen.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\compiler.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\constpool.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\containers.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\context_p.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\cpuinfo.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\cputicks.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\error.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\globals.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\intutil.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\lock.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\logger.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\operand.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\runtime.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\string.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\vectypes.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\vmem.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\zone.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\x86\x86assembler.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\x86\x86compiler.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\x86\x86context_p.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\x86\x86cpuinfo.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\x86\x86inst.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\x86\x86operand.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\x86\x86scheduler_p.h" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{AC40FF01-426E-4838-A317-66354CEFAE88}</ProjectGuid>
+    <RootNamespace>asmjit</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <OutDir>$(SolutionDir)libs\$(Configuration)\</OutDir>
+    <IntDir>
+    </IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <OutDir>$(SolutionDir)libs\$(Configuration)\</OutDir>
+    <IntDir>
+    </IntDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>false</SDLCheck>
+      <PreprocessorDefinitions>ASMJIT_STATIC;_MBCS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>false</SDLCheck>
+      <PreprocessorDefinitions>ASMJIT_STATIC;_UNICODE;UNICODE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

asmjitsrc/asmjit.vcxproj.filters

@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <ClCompile Include="..\asmjit\src\asmjit\base\assembler.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\codegen.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\compiler.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\constpool.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\containers.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\context.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\cpuinfo.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\cputicks.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\error.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\globals.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\intutil.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\logger.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\operand.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\runtime.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\string.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\vmem.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\base\zone.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\x86\x86assembler.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\x86\x86compiler.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\x86\x86context.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\x86\x86cpuinfo.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\x86\x86inst.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\x86\x86operand.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\x86\x86operand_regs.cpp" />
+    <ClCompile Include="..\asmjit\src\asmjit\x86\x86scheduler.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\asmjit\src\asmjit\x86\x86assembler.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\x86\x86compiler.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\x86\x86context_p.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\x86\x86cpuinfo.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\x86\x86inst.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\x86\x86operand.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\x86\x86scheduler_p.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\assembler.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\codegen.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\compiler.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\constpool.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\containers.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\context_p.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\cpuinfo.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\cputicks.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\error.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\globals.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\intutil.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\lock.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\logger.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\operand.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\runtime.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\string.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\vectypes.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\vmem.h" />
+    <ClInclude Include="..\asmjit\src\asmjit\base\zone.h" />
+  </ItemGroup>
+</Project>

asmjitsrc/asmjit.vcxproj.user

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup />
+</Project>

bin/dev_hdd0/home/00000001/exdata/.gitignore

@@ -0,0 +1,6 @@
+# Note: This folder has to exist. Once the User Account manager is implemented, make sure it creates this folder in case it's missing and delete this .gitignore file.
+
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

bin/dev_hdd0/home/00000001/localusername

@@ -0,0 +1 @@
+User

bin/dev_hdd0/home/00000001/savedata/.gitignore

@@ -0,0 +1,6 @@
+# Note: This folder has to exist. Once the User Account manager is implemented, make sure it creates this folder in case it's missing and delete this .gitignore file.
+
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

bin/dev_hdd0/home/00000001/trophy/.gitignore

@@ -0,0 +1,6 @@
+# Note: This folder has to exist. Once the User Account manager is implemented, make sure it creates this folder in case it's missing and delete this .gitignore file.
+
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

bin/dev_hdd1/.gitignore

@@ -0,0 +1,6 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore
+!cache
+!cache/README.txt

bin/dev_hdd1/cache/README.txt

@@ -0,0 +1 @@
+This directory is used for cache functionality, so don't store any data here.

bin/dev_hdd1/game/README.txt

@@ -0,0 +1 @@
+This directory is used for temporary gamedata functionality, so don't store any data here.

bin/dev_usb000/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

llvm_build/UpdateProjectFiles.bat

@@ -0,0 +1,30 @@
+REM You need cmake and python to update the project files
+REM this script relies on CWD being the path that this script is in
+
+cmake -G "Visual Studio 12 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DLLVM_TARGETS_TO_BUILD=X86 -DLLVM_BUILD_RUNTIME=OFF -DLLVM_BUILD_TOOLS=OFF -DLLVM_INCLUDE_DOCS=OFF -DLLVM_INCLUDE_EXAMPLES=OFF -DLLVM_INCLUDE_TESTS=OFF -DLLVM_INCLUDE_TOOLS=OFF -DLLVM_INCLUDE_UTILS=OFF -DWITH_POLLY=OFF ../llvm
+
+RD /S /Q cmake
+RD /S /Q CMakeFiles
+RD /S /Q projects
+RD /S /Q share
+RD /S /Q tools
+DEL ALL_BUILD.vcxproj
+DEL ALL_BUILD.vcxproj.filters
+DEL CMakeCache.txt
+DEL cmake_install.cmake
+DEL CPackConfig.cmake
+DEL CPackSourceConfig.cmake
+DEL DummyConfigureOutput
+DEL INSTALL.vcxproj
+DEL INSTALL.vcxproj.filters
+DEL LLVM.sdf
+DEL LLVM.sln
+DEL LLVMBuild.cmake
+DEL PACKAGE.vcxproj
+DEL PACKAGE.vcxproj.filters
+DEL ZERO_CHECK.vcxproj
+DEL ZERO_CHECK.vcxproj.filters
+DEL include\llvm\llvm_headers_do_not_build.vcxproj
+DEL include\llvm\llvm_headers_do_not_build.vcxproj.filters
+python make_paths_relative.py
+

llvm_build/llvm_build.vcxproj

@@ -0,0 +1,68 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{8BC303AB-25BE-4276-8E57-73F171B2D672}</ProjectGuid>
+    <Keyword>MakeFileProj</Keyword>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Makefile</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Makefile</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <NMakePreprocessorDefinitions>
+    </NMakePreprocessorDefinitions>
+    <NMakeBuildCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DLLVM_TARGETS_TO_BUILD=X86 -DLLVM_BUILD_RUNTIME=OFF -DLLVM_BUILD_TOOLS=OFF -DLLVM_INCLUDE_DOCS=OFF -DLLVM_INCLUDE_EXAMPLES=OFF -DLLVM_INCLUDE_TESTS=OFF -DLLVM_INCLUDE_TOOLS=OFF -DLLVM_INCLUDE_UTILS=OFF -DWITH_POLLY=OFF ../llvm
+msbuild.exe ALL_BUILD.vcxproj /t:build /p:Configuration=Debug
+</NMakeBuildCommandLine>
+    <NMakeReBuildCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DLLVM_TARGETS_TO_BUILD=X86 -DLLVM_BUILD_RUNTIME=OFF -DLLVM_BUILD_TOOLS=OFF -DLLVM_INCLUDE_DOCS=OFF -DLLVM_INCLUDE_EXAMPLES=OFF -DLLVM_INCLUDE_TESTS=OFF -DLLVM_INCLUDE_TOOLS=OFF -DLLVM_INCLUDE_UTILS=OFF -DWITH_POLLY=OFF ../llvm
+msbuild.exe ALL_BUILD.vcxproj /t:rebuild /p:Configuration=Debug
+</NMakeReBuildCommandLine>
+    <NMakeCleanCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DLLVM_TARGETS_TO_BUILD=X86 -DLLVM_BUILD_RUNTIME=OFF -DLLVM_BUILD_TOOLS=OFF -DLLVM_INCLUDE_DOCS=OFF -DLLVM_INCLUDE_EXAMPLES=OFF -DLLVM_INCLUDE_TESTS=OFF -DLLVM_INCLUDE_TOOLS=OFF -DLLVM_INCLUDE_UTILS=OFF -DWITH_POLLY=OFF ../llvm
+msbuild.exe ALL_BUILD.vcxproj /t:clean /p:Configuration=Debug
+</NMakeCleanCommandLine>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <NMakePreprocessorDefinitions />
+    <NMakeBuildCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DLLVM_TARGETS_TO_BUILD=X86 -DLLVM_BUILD_RUNTIME=OFF -DLLVM_BUILD_TOOLS=OFF -DLLVM_INCLUDE_DOCS=OFF -DLLVM_INCLUDE_EXAMPLES=OFF -DLLVM_INCLUDE_TESTS=OFF -DLLVM_INCLUDE_TOOLS=OFF -DLLVM_INCLUDE_UTILS=OFF -DWITH_POLLY=OFF ../llvm
+msbuild.exe ALL_BUILD.vcxproj /t:build /p:Configuration=Release
+</NMakeBuildCommandLine>
+    <NMakeReBuildCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DLLVM_TARGETS_TO_BUILD=X86 -DLLVM_BUILD_RUNTIME=OFF -DLLVM_BUILD_TOOLS=OFF -DLLVM_INCLUDE_DOCS=OFF -DLLVM_INCLUDE_EXAMPLES=OFF -DLLVM_INCLUDE_TESTS=OFF -DLLVM_INCLUDE_TOOLS=OFF -DLLVM_INCLUDE_UTILS=OFF -DWITH_POLLY=OFF ../llvm
+msbuild.exe ALL_BUILD.vcxproj /t:rebuild /p:Configuration=Release
+</NMakeReBuildCommandLine>
+    <NMakeCleanCommandLine>cmake -G "Visual Studio 14 2015 Win64" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -DLLVM_TARGETS_TO_BUILD=X86 -DLLVM_BUILD_RUNTIME=OFF -DLLVM_BUILD_TOOLS=OFF -DLLVM_INCLUDE_DOCS=OFF -DLLVM_INCLUDE_EXAMPLES=OFF -DLLVM_INCLUDE_TESTS=OFF -DLLVM_INCLUDE_TOOLS=OFF -DLLVM_INCLUDE_UTILS=OFF -DWITH_POLLY=OFF ../llvm
+msbuild.exe ALL_BUILD.vcxproj /t:clean /p:Configuration=Release
+</NMakeCleanCommandLine>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

llvm_build/llvm_build.vcxproj.filters

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+</Project>

llvm_build/make_paths_relative.py

@@ -0,0 +1,164 @@
+import os
+import shutil
+import xml.etree.ElementTree as ET
+import re
+
+RPCS3DIR = ""
+
+cmake_dirs = ["CMakeFiles",]
+
+cmake_files = ["INSTALL.vcxproj",
+               "INSTALL.vcxproj.filters",
+               "PACKAGE.vcxproj",
+               "PACKAGE.vcxproj.filters",
+               "cmake_install.cmake",
+               ]
+
+vcxproj_files_blacklist = ["llvm_build.vcxproj","llvm_build.vcxproj.filters"]
+
+vcxproj_files = ["lib\Analysis\LLVMAnalysis.vcxproj",
+                "lib\Analysis\IPA\LLVMipa.vcxproj",
+                "lib\AsmParser\LLVMAsmParser.vcxproj",
+                "lib\Bitcode\Reader\LLVMBitReader.vcxproj",
+                "lib\Bitcode\Writer\LLVMBitWriter.vcxproj",
+                "lib\CodeGen\LLVMCodeGen.vcxproj",
+                "lib\CodeGen\AsmPrinter\LLVMAsmPrinter.vcxproj",
+                "lib\CodeGen\SelectionDAG\LLVMSelectionDAG.vcxproj",
+                "lib\DebugInfo\LLVMDebugInfo.vcxproj",
+                "lib\ExecutionEngine\LLVMExecutionEngine.vcxproj",
+                "lib\ExecutionEngine\Interpreter\LLVMInterpreter.vcxproj",
+                "lib\ExecutionEngine\JIT\LLVMJIT.vcxproj",
+                "lib\ExecutionEngine\MCJIT\LLVMMCJIT.vcxproj",
+                "lib\ExecutionEngine\RuntimeDyld\LLVMRuntimeDyld.vcxproj",
+                "lib\IR\LLVMCore.vcxproj",
+                "lib\IRReader\LLVMIRReader.vcxproj",
+                "lib\LineEditor\LLVMLineEditor.vcxproj",
+                "lib\Linker\LLVMLinker.vcxproj",
+                "lib\LTO\LLVMLTO.vcxproj",
+                "lib\MC\LLVMMC.vcxproj",
+                "lib\MC\MCAnalysis\LLVMMCAnalysis.vcxproj",
+                "lib\MC\MCDisassembler\LLVMMCDisassembler.vcxproj",
+                "lib\MC\MCParser\LLVMMCParser.vcxproj",
+                "lib\Object\LLVMObject.vcxproj",
+                "lib\Option\LLVMOption.vcxproj",
+                "lib\ProfileData\LLVMProfileData.vcxproj",
+                "lib\Support\LLVMSupport.vcxproj",
+                "lib\TableGen\LLVMTableGen.vcxproj",
+                "lib\Target\LLVMTarget.vcxproj",
+                "lib\Target\X86\LLVMX86CodeGen.vcxproj",
+                "lib\Target\X86\X86CommonTableGen.vcxproj",
+                "lib\Target\X86\AsmParser\LLVMX86AsmParser.vcxproj",
+                "lib\Target\X86\Disassembler\LLVMX86Disassembler.vcxproj",
+                "lib\Target\X86\InstPrinter\LLVMX86AsmPrinter.vcxproj",
+                "lib\Target\X86\MCTargetDesc\LLVMX86Desc.vcxproj",
+                "lib\Target\X86\TargetInfo\LLVMX86Info.vcxproj",
+                "lib\Target\X86\Utils\LLVMX86Utils.vcxproj",
+                "lib\Transforms\Hello\LLVMHello.vcxproj",
+                "lib\Transforms\InstCombine\LLVMInstCombine.vcxproj",
+                "lib\Transforms\Instrumentation\LLVMInstrumentation.vcxproj",
+                "lib\Transforms\IPO\LLVMipo.vcxproj",
+                "lib\Transforms\ObjCARC\LLVMObjCARCOpts.vcxproj",
+                "lib\Transforms\Scalar\LLVMScalarOpts.vcxproj",
+                "lib\Transforms\Utils\LLVMTransformUtils.vcxproj",
+                "lib\Transforms\Vectorize\LLVMVectorize.vcxproj",
+                "include\llvm\IR\intrinsics_gen.vcxproj",
+                "utils\TableGen\llvm-tblgen.vcxproj",
+                 ]
+
+def get_parent_dir():
+    path = os.getcwd()
+    os.chdir("..")
+    rpcs3_dir = os.getcwd()
+    os.chdir(path)
+    return rpcs3_dir
+
+def rem_cmake_files(root_path):
+    for root, dirs, files in os.walk(root_path):
+        for directory in dirs:
+            if directory in cmake_dirs:
+                print("deleting: " + os.path.join(root,directory))
+                shutil.rmtree(os.path.join(root,directory))
+        dirs = [item for item in dirs if item not in cmake_dirs]
+        for file in files:
+            if file in cmake_files:
+                print("deleting: " + os.path.join(root,file))
+                os.remove(os.path.join(root,file))
+
+def repl_cmake_copy(match):
+    newtext = "copy /y "
+    files = match.group(1)
+    files = files.replace('/','\\')
+    return newtext+files
+
+def make_paths_relative(file):
+    global vcxproj_files
+    global vcxproj_files_blacklist
+    this_vcxproj = os.path.relpath(file,os.getcwd())
+    if this_vcxproj in vcxproj_files_blacklist:
+        return
+    if (file.find('.vcxproj')!=len(file)-8) and (file.find('.vcxproj.filters')!=len(file)-16):
+        print('ERROR: File "'+file+'" is not vcxproj file')
+        return
+    proj_path = os.path.dirname(file)
+    if proj_path[1] != ':':
+        print('ERROR: Path "'+proj_path+'" is not in the Windows format')
+        return
+    #check if we expected this project file
+    if file[-8:] == '.vcxproj':
+        if this_vcxproj in vcxproj_files:
+            vcxproj_files.remove(this_vcxproj)
+        else:
+            print('ERROR: unexpected vcxproj file: "' + this_vcxproj +'" please update the script')
+            return
+
+    #open the file and text-replace the absolute paths
+    with open(file,'r') as f:
+        file_cont = f.read()
+    rel_path = '$(ProjDir)'+os.path.relpath(RPCS3DIR,proj_path)
+    file_cont = file_cont.replace(RPCS3DIR,rel_path)
+    rpcs3_path_alt = RPCS3DIR.replace('\\','/')
+    rel_path_alt = rel_path.replace('\\','/')
+    file_cont = file_cont.replace(rpcs3_path_alt,rel_path_alt)
+    
+    #interpret the XML to remove the cmake commands from the "Command" tags
+    ET.register_namespace('','http://schemas.microsoft.com/developer/msbuild/2003')
+    tree = ET.fromstring(file_cont)
+    
+    for parent in tree.findall('.//{http://schemas.microsoft.com/developer/msbuild/2003}Command/..'):
+        for element in parent.findall('{http://schemas.microsoft.com/developer/msbuild/2003}Command'):
+            text = str(element.text)
+            rgx = re.compile(r'[^\r\n<>]+cmake.exe["]?\s+-E copy_if_different([^\r\n]+)')
+            text, num_rep = rgx.subn(repl_cmake_copy,text)
+            rgx = re.compile(r'[^\r\n<>]+cmake.exe([^\r\n]*)')
+            text, num_rep2 = rgx.subn(r'REM OMMITTED CMAKE COMMAND',text)
+            num_rep += num_rep2
+            rgx = re.compile(r'[^\r\n<>]+ml64.exe"?([^\r\n]*)')
+            text, num_rep2 = rgx.subn(r'"$(VCInstallDir)bin\x86_amd64\ml64.exe" \1',text)
+            num_rep += num_rep2
+            #if (text.find('cmake') != -1) or (text.find('python') != -1):
+            #    parent.remove(element)
+            if num_rep > 0:
+                element.text = text
+
+    #re-create the XML and save the file
+    file_cont = ET.tostring(tree,'utf-8')                                  
+    with open(file,'w') as f:
+        f.write(file_cont)
+                                      
+    
+def iterate_proj_file(root_path):
+    for root, dirs, files in os.walk(root_path):
+        for file in files:
+            if file.find('.vcxproj') != -1 :
+                make_paths_relative(os.path.join(root,file))
+
+def main_func():
+    global RPCS3DIR
+    RPCS3DIR = get_parent_dir()
+    rem_cmake_files(os.getcwd())
+    iterate_proj_file(os.getcwd())
+    for a in vcxproj_files:
+        print('ERROR: project file was not found "'+ a + '"')
+
+if __name__ == "__main__":
+    main_func()

rpcs3/AppConnector.cpp

@@ -1,32 +0,0 @@
-#include "stdafx.h"
-#include "AppConnector.h"
-
-AppConnector::~AppConnector()
-{
-	for(uint i=0; i<m_connect_arr.GetCount(); ++i)
-	{
-		wxGetApp().Disconnect(
-			m_connect_arr[i].winid,
-			m_connect_arr[i].lastId,
-			m_connect_arr[i].eventType,
-			m_connect_arr[i].func,
-			m_connect_arr[i].userData,
-			m_connect_arr[i].eventSink);
-	}
-}
-
-void AppConnector::Connect(int winid, int lastId, int eventType, wxObjectEventFunction func, wxObject* userData, wxEvtHandler* eventSink)
-{
-	m_connect_arr.Move(new ConnectInfo(winid, lastId, eventType, func, userData, eventSink));
-	wxGetApp().Connect(winid, lastId, eventType, func, userData, eventSink);
-}
-
-void AppConnector::Connect(int winid, int eventType, wxObjectEventFunction func, wxObject* userData, wxEvtHandler* eventSink)
-{
-	Connect(winid, wxID_ANY, eventType, func, userData, eventSink);
-}
-
-void AppConnector::Connect(int eventType, wxObjectEventFunction func, wxObject* userData, wxEvtHandler* eventSink)
-{
-	Connect(wxID_ANY, wxID_ANY, eventType, func, userData, eventSink);
-}

rpcs3/AppConnector.h

@@ -1,33 +0,0 @@
-#pragma once
-
-class AppConnector
-{
-	struct ConnectInfo
-	{
-		int winid;
-		int lastId;
-		int eventType;
-		wxObjectEventFunction func;
-		wxObject* userData;
-		wxEvtHandler* eventSink;
-
-		ConnectInfo(int winid, int lastId, int eventType, wxObjectEventFunction func, wxObject* userData, wxEvtHandler* eventSink)
-			: winid(winid)
-			, lastId(lastId)
-			, eventType(eventType)
-			, func(func)
-			, userData(userData)
-			, eventSink(eventSink)
-		{
-		}
-	};
-
-	Array<ConnectInfo> m_connect_arr;
-
-public:
-	~AppConnector();
-
-	void Connect(int winid, int lastId, int eventType, wxObjectEventFunction func, wxObject* userData = nullptr, wxEvtHandler* eventSink = nullptr);
-	void Connect(int winid, int eventType, wxObjectEventFunction func, wxObject* userData = nullptr, wxEvtHandler* eventSink = nullptr);
-	void Connect(int eventType, wxObjectEventFunction func, wxObject* userData = nullptr, wxEvtHandler* eventSink = nullptr);
-};

rpcs3/CMakeLists.txt

@@ -0,0 +1,178 @@
+cmake_minimum_required(VERSION 2.8.12)
+
+set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake_modules")
+include(cotire)
+
+project(rpcs3)
+
+# Generate git-version.h at build time.
+add_custom_target(GitVersion ALL
+	DEPENDS something_that_never_exists)
+add_custom_command(OUTPUT something_that_never_exists
+	COMMAND ${CMAKE_COMMAND} -DSOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}
+		-P ${CMAKE_CURRENT_SOURCE_DIR}/git-version.cmake)
+
+if(CMAKE_COMPILER_IS_GNUCXX)
+	if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.7.0)
+		message(FATAL_ERROR "GCC ${CMAKE_CXX_COMPILER_VERSION} is too old.")
+	endif()
+	# Warnings
+	add_compile_options(-Wno-attributes -Wno-enum-compare -Wno-invalid-offsetof)
+elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+	if(APPLE)
+		add_compile_options(-stdlib=libc++)
+	endif()
+endif()
+
+if(NOT MSVC)
+	add_definitions(-DwxGUI)
+	if($ENV{CI})
+		set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O1") # fix for travis gcc OoM crash. Might be fixed with the move to containers.
+	endif()
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fexceptions")
+	add_compile_options(-msse -msse2 -mcx16 -mssse3)
+else()
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHa /Zc:throwingNew /D _CRT_SECURE_NO_DEPRECATE=1 /D _CRT_NON_CONFORMING_SWPRINTFS=1 /D _SCL_SECURE_NO_WARNINGS=1")
+endif()
+
+if(APPLE)
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I/opt/X11/include")
+	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -I/opt/X11/include")
+endif()
+
+if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+	#on some Linux distros shm_unlink and similar functions are in librt only
+	set(ADDITIONAL_LIBS "rt" "X11")
+elseif(UNIX)
+	#it seems like glibc includes the iconv functions we use but other libc
+	#implementations like the one on OSX don't seem implement them
+	set(ADDITIONAL_LIBS "iconv")
+else()
+	set(ADDITIONAL_LIBS "")
+endif()
+
+If(NOT RPCS3_SRC_DIR)
+  SET(RPCS3_SRC_DIR ${CMAKE_CURRENT_LIST_DIR})
+  Message("-- Initializing RPCS3_SRC_DIR=${RPCS3_SRC_DIR}")
+Else()
+  Message("-- Using Custom RPCS3_SRC_DIR=${RPCS3_SRC_DIR}")
+EndIf()
+
+set(CMAKE_MODULE_PATH "${RPCS3_SRC_DIR}/cmake_modules")
+
+if(NOT WIN32)
+	add_definitions(-DGL_GLEXT_PROTOTYPES)
+	add_definitions(-DGLX_GLXEXT_PROTOTYPES)
+endif()
+
+find_package(wxWidgets COMPONENTS core base net aui gl xml REQUIRED)
+if(NOT WIN32)
+	if(APPLE)
+		find_path(GLEW_INCLUDE_DIR GL/glew.h
+			/usr/include/GL
+			/usr/openwin/share/include
+			/usr/openwin/include
+			/usr/X11R6/include
+			/usr/include/X11
+			/opt/graphics/OpenGL/include
+			/opt/graphics/OpenGL/contrib/libglew
+			/usr/local/include
+		)
+	endif()
+	find_package(GLEW REQUIRED)
+	find_package(ZLIB REQUIRED)
+endif()
+find_package(OpenGL REQUIRED)
+find_package(OpenAL REQUIRED)
+find_package(LLVM CONFIG)
+
+include("${wxWidgets_USE_FILE}")
+
+if(APPLE)
+	set(PLATFORM_ARCH "macosx/x86_64")
+elseif(WIN32)
+	set(PLATFORM_ARCH "Windows/x86_64")
+else()
+	set(PLATFORM_ARCH "linux/x86_64")
+endif()
+
+include_directories(
+${GLEW_INCLUDE_DIR}
+${wxWidgets_INCLUDE_DIRS}
+${OPENAL_INCLUDE_DIR}
+${LLVM_INCLUDE_DIRS}
+"${RPCS3_SRC_DIR}/../ffmpeg/${PLATFORM_ARCH}/include"
+"${RPCS3_SRC_DIR}"
+"${RPCS3_SRC_DIR}/Loader"
+"${RPCS3_SRC_DIR}/Crypto"
+"${RPCS3_SRC_DIR}/.."
+"${RPCS3_SRC_DIR}/../asmjit/src/asmjit"
+)
+if(WIN32)
+	include_directories(BEFORE "${RPCS3_SRC_DIR}/../minidx9/Include")
+endif()
+
+if(LLVM_FOUND)
+	add_definitions(${LLVM_DEFINITIONS})
+	add_definitions(-DLLVM_AVAILABLE)
+	if (CMAKE_BUILD_TYPE STREQUAL "Release")
+		llvm_map_components_to_libnames(LLVM_LIBS mcjit vectorize x86codegen x86disassembler)
+	else()
+		llvm_map_components_to_libnames(LLVM_LIBS mcjit vectorize x86codegen x86disassembler mcdisassembler)
+	endif()
+	if(MSVC)
+		set_source_files_properties(${RPCS3_SRC_DIR}/Emu/Cell/PPULLVMRecompiler.cpp PROPERTIES COMPILE_FLAGS /GR-)
+	else()
+		set_source_files_properties(${RPCS3_SRC_DIR}/Emu/Cell/PPULLVMRecompiler.cpp PROPERTIES COMPILE_FLAGS -fno-rtti)
+	endif()
+endif()
+
+link_directories("${RPCS3_SRC_DIR}/../ffmpeg/${PLATFORM_ARCH}/lib" "${RPCS3_SRC_DIR}/../asmjit/")
+
+get_property(dirs DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY INCLUDE_DIRECTORIES)
+foreach(dir ${dirs})
+  message(STATUS "dir='${dir}'")
+endforeach()
+
+file(
+GLOB_RECURSE
+RPCS3_SRC
+"${RPCS3_SRC_DIR}/rpcs3.cpp"
+"${RPCS3_SRC_DIR}/Ini.cpp"
+"${RPCS3_SRC_DIR}/../Utilities/GNU.cpp"
+"${RPCS3_SRC_DIR}/Emu/*"
+"${RPCS3_SRC_DIR}/Gui/*"
+"${RPCS3_SRC_DIR}/Loader/*"
+"${RPCS3_SRC_DIR}/Crypto/*"
+"${RPCS3_SRC_DIR}/../Utilities/*"
+)
+
+list(REMOVE_ITEM RPCS3_SRC ${RPCS3_SRC_DIR}/../Utilities/simpleini/ConvertUTF.c)
+
+add_executable(rpcs3 ${RPCS3_SRC})
+
+if(NOT MSVC)
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -L${CMAKE_CURRENT_BINARY_DIR}/../asmjit/") #hack because the asmjit cmake file force fno exceptions upd: not sure if vs2015 build is affected
+else()
+	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SUBSYSTEM:WINDOWS /NODEFAULTLIB:libc.lib /NODEFAULTLIB:libcmt.lib /NODEFAULTLIB:libcd.lib /NODEFAULTLIB:libcmtd.lib /NODEFAULTLIB:msvcrtd.lib")
+endif()
+if(WIN32) # I'm not sure we need all of these libs, but we link them in vs
+	target_link_libraries(rpcs3  odbc32.lib odbccp32.lib comctl32.lib ws2_32.lib shlwapi.lib winmm.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib)
+	if(LLVM_FOUND)
+		target_link_libraries(rpcs3  asmjit.lib ${wxWidgets_LIBRARIES} ${OPENAL_LIBRARY} avformat.lib avcodec.lib avutil.lib swresample.lib swscale.lib ${LLVM_LIBS} ${ADDITIONAL_LIBS})
+	else()
+		target_link_libraries(rpcs3  asmjit.lib ${wxWidgets_LIBRARIES} ${OPENAL_LIBRARY} avformat.lib avcodec.lib avutil.lib swresample.lib swscale.lib ${ADDITIONAL_LIBS})
+	endif()
+else()
+	if(LLVM_FOUND)
+		target_link_libraries(rpcs3  asmjit.a  ${wxWidgets_LIBRARIES} ${OPENAL_LIBRARY} ${GLEW_LIBRARY} ${OPENGL_LIBRARIES})
+		target_link_libraries(rpcs3  libavformat.a libavcodec.a libavutil.a libswresample.a libswscale.a ${ZLIB_LIBRARIES} ${LLVM_LIBS} ${ADDITIONAL_LIBS})
+	else()
+		target_link_libraries(rpcs3  asmjit.a  ${wxWidgets_LIBRARIES} ${OPENAL_LIBRARY} ${GLEW_LIBRARY} ${OPENGL_LIBRARIES})
+		target_link_libraries(rpcs3  libavformat.a libavcodec.a libavutil.a libswresample.a libswscale.a ${ZLIB_LIBRARIES} ${ADDITIONAL_LIBS})
+    endif()
+endif()
+
+set_target_properties(rpcs3 PROPERTIES COTIRE_CXX_PREFIX_HEADER_INIT "${RPCS3_SRC_DIR}/stdafx.h")
+cotire(rpcs3)
+

rpcs3/Crypto/aes.cpp

@@ -0,0 +1,975 @@
+/*
+ *  FIPS-197 compliant AES implementation
+ *
+ *  Copyright (C) 2006-2013, Brainspark B.V.
+ *
+ *  This file is part of PolarSSL (http://www.polarssl.org)
+ *  Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
+ *
+ *  All rights reserved.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  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 for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+/*
+ *  The AES block cipher was designed by Vincent Rijmen and Joan Daemen.
+ *
+ *  http://csrc.nist.gov/encryption/aes/rijndael/Rijndael.pdf
+ *  http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf
+ */
+
+#include "stdafx.h"
+#include "aes.h"
+
+/*
+ * 32-bit integer manipulation macros (little endian)
+ */
+#ifndef GET_UINT32_LE
+#define GET_UINT32_LE(n,b,i)                            \
+{                                                       \
+    (n) = ( (uint32_t) (b)[(i)    ]       )             \
+        | ( (uint32_t) (b)[(i) + 1] <<  8 )             \
+        | ( (uint32_t) (b)[(i) + 2] << 16 )             \
+        | ( (uint32_t) (b)[(i) + 3] << 24 );            \
+}
+#endif
+
+#ifndef PUT_UINT32_LE
+#define PUT_UINT32_LE(n,b,i)                            \
+{                                                       \
+    (b)[(i)    ] = (unsigned char) ( (n)       );       \
+    (b)[(i) + 1] = (unsigned char) ( (n) >>  8 );       \
+    (b)[(i) + 2] = (unsigned char) ( (n) >> 16 );       \
+    (b)[(i) + 3] = (unsigned char) ( (n) >> 24 );       \
+}
+#endif
+
+#if defined(POLARSSL_AES_ROM_TABLES)
+/*
+ * Forward S-box
+ */
+static const unsigned char FSb[256] =
+{
+    0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5,
+    0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
+    0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0,
+    0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
+    0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC,
+    0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
+    0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A,
+    0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
+    0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0,
+    0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
+    0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B,
+    0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
+    0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85,
+    0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
+    0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5,
+    0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
+    0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17,
+    0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
+    0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88,
+    0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
+    0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C,
+    0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
+    0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9,
+    0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
+    0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6,
+    0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
+    0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E,
+    0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
+    0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94,
+    0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
+    0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68,
+    0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
+};
+
+/*
+ * Forward tables
+ */
+#define FT \
+\
+    V(A5,63,63,C6), V(84,7C,7C,F8), V(99,77,77,EE), V(8D,7B,7B,F6), \
+    V(0D,F2,F2,FF), V(BD,6B,6B,D6), V(B1,6F,6F,DE), V(54,C5,C5,91), \
+    V(50,30,30,60), V(03,01,01,02), V(A9,67,67,CE), V(7D,2B,2B,56), \
+    V(19,FE,FE,E7), V(62,D7,D7,B5), V(E6,AB,AB,4D), V(9A,76,76,EC), \
+    V(45,CA,CA,8F), V(9D,82,82,1F), V(40,C9,C9,89), V(87,7D,7D,FA), \
+    V(15,FA,FA,EF), V(EB,59,59,B2), V(C9,47,47,8E), V(0B,F0,F0,FB), \
+    V(EC,AD,AD,41), V(67,D4,D4,B3), V(FD,A2,A2,5F), V(EA,AF,AF,45), \
+    V(BF,9C,9C,23), V(F7,A4,A4,53), V(96,72,72,E4), V(5B,C0,C0,9B), \
+    V(C2,B7,B7,75), V(1C,FD,FD,E1), V(AE,93,93,3D), V(6A,26,26,4C), \
+    V(5A,36,36,6C), V(41,3F,3F,7E), V(02,F7,F7,F5), V(4F,CC,CC,83), \
+    V(5C,34,34,68), V(F4,A5,A5,51), V(34,E5,E5,D1), V(08,F1,F1,F9), \
+    V(93,71,71,E2), V(73,D8,D8,AB), V(53,31,31,62), V(3F,15,15,2A), \
+    V(0C,04,04,08), V(52,C7,C7,95), V(65,23,23,46), V(5E,C3,C3,9D), \
+    V(28,18,18,30), V(A1,96,96,37), V(0F,05,05,0A), V(B5,9A,9A,2F), \
+    V(09,07,07,0E), V(36,12,12,24), V(9B,80,80,1B), V(3D,E2,E2,DF), \
+    V(26,EB,EB,CD), V(69,27,27,4E), V(CD,B2,B2,7F), V(9F,75,75,EA), \
+    V(1B,09,09,12), V(9E,83,83,1D), V(74,2C,2C,58), V(2E,1A,1A,34), \
+    V(2D,1B,1B,36), V(B2,6E,6E,DC), V(EE,5A,5A,B4), V(FB,A0,A0,5B), \
+    V(F6,52,52,A4), V(4D,3B,3B,76), V(61,D6,D6,B7), V(CE,B3,B3,7D), \
+    V(7B,29,29,52), V(3E,E3,E3,DD), V(71,2F,2F,5E), V(97,84,84,13), \
+    V(F5,53,53,A6), V(68,D1,D1,B9), V(00,00,00,00), V(2C,ED,ED,C1), \
+    V(60,20,20,40), V(1F,FC,FC,E3), V(C8,B1,B1,79), V(ED,5B,5B,B6), \
+    V(BE,6A,6A,D4), V(46,CB,CB,8D), V(D9,BE,BE,67), V(4B,39,39,72), \
+    V(DE,4A,4A,94), V(D4,4C,4C,98), V(E8,58,58,B0), V(4A,CF,CF,85), \
+    V(6B,D0,D0,BB), V(2A,EF,EF,C5), V(E5,AA,AA,4F), V(16,FB,FB,ED), \
+    V(C5,43,43,86), V(D7,4D,4D,9A), V(55,33,33,66), V(94,85,85,11), \
+    V(CF,45,45,8A), V(10,F9,F9,E9), V(06,02,02,04), V(81,7F,7F,FE), \
+    V(F0,50,50,A0), V(44,3C,3C,78), V(BA,9F,9F,25), V(E3,A8,A8,4B), \
+    V(F3,51,51,A2), V(FE,A3,A3,5D), V(C0,40,40,80), V(8A,8F,8F,05), \
+    V(AD,92,92,3F), V(BC,9D,9D,21), V(48,38,38,70), V(04,F5,F5,F1), \
+    V(DF,BC,BC,63), V(C1,B6,B6,77), V(75,DA,DA,AF), V(63,21,21,42), \
+    V(30,10,10,20), V(1A,FF,FF,E5), V(0E,F3,F3,FD), V(6D,D2,D2,BF), \
+    V(4C,CD,CD,81), V(14,0C,0C,18), V(35,13,13,26), V(2F,EC,EC,C3), \
+    V(E1,5F,5F,BE), V(A2,97,97,35), V(CC,44,44,88), V(39,17,17,2E), \
+    V(57,C4,C4,93), V(F2,A7,A7,55), V(82,7E,7E,FC), V(47,3D,3D,7A), \
+    V(AC,64,64,C8), V(E7,5D,5D,BA), V(2B,19,19,32), V(95,73,73,E6), \
+    V(A0,60,60,C0), V(98,81,81,19), V(D1,4F,4F,9E), V(7F,DC,DC,A3), \
+    V(66,22,22,44), V(7E,2A,2A,54), V(AB,90,90,3B), V(83,88,88,0B), \
+    V(CA,46,46,8C), V(29,EE,EE,C7), V(D3,B8,B8,6B), V(3C,14,14,28), \
+    V(79,DE,DE,A7), V(E2,5E,5E,BC), V(1D,0B,0B,16), V(76,DB,DB,AD), \
+    V(3B,E0,E0,DB), V(56,32,32,64), V(4E,3A,3A,74), V(1E,0A,0A,14), \
+    V(DB,49,49,92), V(0A,06,06,0C), V(6C,24,24,48), V(E4,5C,5C,B8), \
+    V(5D,C2,C2,9F), V(6E,D3,D3,BD), V(EF,AC,AC,43), V(A6,62,62,C4), \
+    V(A8,91,91,39), V(A4,95,95,31), V(37,E4,E4,D3), V(8B,79,79,F2), \
+    V(32,E7,E7,D5), V(43,C8,C8,8B), V(59,37,37,6E), V(B7,6D,6D,DA), \
+    V(8C,8D,8D,01), V(64,D5,D5,B1), V(D2,4E,4E,9C), V(E0,A9,A9,49), \
+    V(B4,6C,6C,D8), V(FA,56,56,AC), V(07,F4,F4,F3), V(25,EA,EA,CF), \
+    V(AF,65,65,CA), V(8E,7A,7A,F4), V(E9,AE,AE,47), V(18,08,08,10), \
+    V(D5,BA,BA,6F), V(88,78,78,F0), V(6F,25,25,4A), V(72,2E,2E,5C), \
+    V(24,1C,1C,38), V(F1,A6,A6,57), V(C7,B4,B4,73), V(51,C6,C6,97), \
+    V(23,E8,E8,CB), V(7C,DD,DD,A1), V(9C,74,74,E8), V(21,1F,1F,3E), \
+    V(DD,4B,4B,96), V(DC,BD,BD,61), V(86,8B,8B,0D), V(85,8A,8A,0F), \
+    V(90,70,70,E0), V(42,3E,3E,7C), V(C4,B5,B5,71), V(AA,66,66,CC), \
+    V(D8,48,48,90), V(05,03,03,06), V(01,F6,F6,F7), V(12,0E,0E,1C), \
+    V(A3,61,61,C2), V(5F,35,35,6A), V(F9,57,57,AE), V(D0,B9,B9,69), \
+    V(91,86,86,17), V(58,C1,C1,99), V(27,1D,1D,3A), V(B9,9E,9E,27), \
+    V(38,E1,E1,D9), V(13,F8,F8,EB), V(B3,98,98,2B), V(33,11,11,22), \
+    V(BB,69,69,D2), V(70,D9,D9,A9), V(89,8E,8E,07), V(A7,94,94,33), \
+    V(B6,9B,9B,2D), V(22,1E,1E,3C), V(92,87,87,15), V(20,E9,E9,C9), \
+    V(49,CE,CE,87), V(FF,55,55,AA), V(78,28,28,50), V(7A,DF,DF,A5), \
+    V(8F,8C,8C,03), V(F8,A1,A1,59), V(80,89,89,09), V(17,0D,0D,1A), \
+    V(DA,BF,BF,65), V(31,E6,E6,D7), V(C6,42,42,84), V(B8,68,68,D0), \
+    V(C3,41,41,82), V(B0,99,99,29), V(77,2D,2D,5A), V(11,0F,0F,1E), \
+    V(CB,B0,B0,7B), V(FC,54,54,A8), V(D6,BB,BB,6D), V(3A,16,16,2C)
+
+#define V(a,b,c,d) 0x##a##b##c##d
+static const uint32_t FT0[256] = { FT };
+#undef V
+
+#define V(a,b,c,d) 0x##b##c##d##a
+static const uint32_t FT1[256] = { FT };
+#undef V
+
+#define V(a,b,c,d) 0x##c##d##a##b
+static const uint32_t FT2[256] = { FT };
+#undef V
+
+#define V(a,b,c,d) 0x##d##a##b##c
+static const uint32_t FT3[256] = { FT };
+#undef V
+
+#undef FT
+
+/*
+ * Reverse S-box
+ */
+static const unsigned char RSb[256] =
+{
+    0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38,
+    0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
+    0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87,
+    0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
+    0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D,
+    0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
+    0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2,
+    0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
+    0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16,
+    0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
+    0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA,
+    0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
+    0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A,
+    0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
+    0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02,
+    0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
+    0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA,
+    0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
+    0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85,
+    0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
+    0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89,
+    0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
+    0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20,
+    0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
+    0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31,
+    0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
+    0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D,
+    0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
+    0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0,
+    0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
+    0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26,
+    0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
+};
+
+/*
+ * Reverse tables
+ */
+#define RT \
+\
+    V(50,A7,F4,51), V(53,65,41,7E), V(C3,A4,17,1A), V(96,5E,27,3A), \
+    V(CB,6B,AB,3B), V(F1,45,9D,1F), V(AB,58,FA,AC), V(93,03,E3,4B), \
+    V(55,FA,30,20), V(F6,6D,76,AD), V(91,76,CC,88), V(25,4C,02,F5), \
+    V(FC,D7,E5,4F), V(D7,CB,2A,C5), V(80,44,35,26), V(8F,A3,62,B5), \
+    V(49,5A,B1,DE), V(67,1B,BA,25), V(98,0E,EA,45), V(E1,C0,FE,5D), \
+    V(02,75,2F,C3), V(12,F0,4C,81), V(A3,97,46,8D), V(C6,F9,D3,6B), \
+    V(E7,5F,8F,03), V(95,9C,92,15), V(EB,7A,6D,BF), V(DA,59,52,95), \
+    V(2D,83,BE,D4), V(D3,21,74,58), V(29,69,E0,49), V(44,C8,C9,8E), \
+    V(6A,89,C2,75), V(78,79,8E,F4), V(6B,3E,58,99), V(DD,71,B9,27), \
+    V(B6,4F,E1,BE), V(17,AD,88,F0), V(66,AC,20,C9), V(B4,3A,CE,7D), \
+    V(18,4A,DF,63), V(82,31,1A,E5), V(60,33,51,97), V(45,7F,53,62), \
+    V(E0,77,64,B1), V(84,AE,6B,BB), V(1C,A0,81,FE), V(94,2B,08,F9), \
+    V(58,68,48,70), V(19,FD,45,8F), V(87,6C,DE,94), V(B7,F8,7B,52), \
+    V(23,D3,73,AB), V(E2,02,4B,72), V(57,8F,1F,E3), V(2A,AB,55,66), \
+    V(07,28,EB,B2), V(03,C2,B5,2F), V(9A,7B,C5,86), V(A5,08,37,D3), \
+    V(F2,87,28,30), V(B2,A5,BF,23), V(BA,6A,03,02), V(5C,82,16,ED), \
+    V(2B,1C,CF,8A), V(92,B4,79,A7), V(F0,F2,07,F3), V(A1,E2,69,4E), \
+    V(CD,F4,DA,65), V(D5,BE,05,06), V(1F,62,34,D1), V(8A,FE,A6,C4), \
+    V(9D,53,2E,34), V(A0,55,F3,A2), V(32,E1,8A,05), V(75,EB,F6,A4), \
+    V(39,EC,83,0B), V(AA,EF,60,40), V(06,9F,71,5E), V(51,10,6E,BD), \
+    V(F9,8A,21,3E), V(3D,06,DD,96), V(AE,05,3E,DD), V(46,BD,E6,4D), \
+    V(B5,8D,54,91), V(05,5D,C4,71), V(6F,D4,06,04), V(FF,15,50,60), \
+    V(24,FB,98,19), V(97,E9,BD,D6), V(CC,43,40,89), V(77,9E,D9,67), \
+    V(BD,42,E8,B0), V(88,8B,89,07), V(38,5B,19,E7), V(DB,EE,C8,79), \
+    V(47,0A,7C,A1), V(E9,0F,42,7C), V(C9,1E,84,F8), V(00,00,00,00), \
+    V(83,86,80,09), V(48,ED,2B,32), V(AC,70,11,1E), V(4E,72,5A,6C), \
+    V(FB,FF,0E,FD), V(56,38,85,0F), V(1E,D5,AE,3D), V(27,39,2D,36), \
+    V(64,D9,0F,0A), V(21,A6,5C,68), V(D1,54,5B,9B), V(3A,2E,36,24), \
+    V(B1,67,0A,0C), V(0F,E7,57,93), V(D2,96,EE,B4), V(9E,91,9B,1B), \
+    V(4F,C5,C0,80), V(A2,20,DC,61), V(69,4B,77,5A), V(16,1A,12,1C), \
+    V(0A,BA,93,E2), V(E5,2A,A0,C0), V(43,E0,22,3C), V(1D,17,1B,12), \
+    V(0B,0D,09,0E), V(AD,C7,8B,F2), V(B9,A8,B6,2D), V(C8,A9,1E,14), \
+    V(85,19,F1,57), V(4C,07,75,AF), V(BB,DD,99,EE), V(FD,60,7F,A3), \
+    V(9F,26,01,F7), V(BC,F5,72,5C), V(C5,3B,66,44), V(34,7E,FB,5B), \
+    V(76,29,43,8B), V(DC,C6,23,CB), V(68,FC,ED,B6), V(63,F1,E4,B8), \
+    V(CA,DC,31,D7), V(10,85,63,42), V(40,22,97,13), V(20,11,C6,84), \
+    V(7D,24,4A,85), V(F8,3D,BB,D2), V(11,32,F9,AE), V(6D,A1,29,C7), \
+    V(4B,2F,9E,1D), V(F3,30,B2,DC), V(EC,52,86,0D), V(D0,E3,C1,77), \
+    V(6C,16,B3,2B), V(99,B9,70,A9), V(FA,48,94,11), V(22,64,E9,47), \
+    V(C4,8C,FC,A8), V(1A,3F,F0,A0), V(D8,2C,7D,56), V(EF,90,33,22), \
+    V(C7,4E,49,87), V(C1,D1,38,D9), V(FE,A2,CA,8C), V(36,0B,D4,98), \
+    V(CF,81,F5,A6), V(28,DE,7A,A5), V(26,8E,B7,DA), V(A4,BF,AD,3F), \
+    V(E4,9D,3A,2C), V(0D,92,78,50), V(9B,CC,5F,6A), V(62,46,7E,54), \
+    V(C2,13,8D,F6), V(E8,B8,D8,90), V(5E,F7,39,2E), V(F5,AF,C3,82), \
+    V(BE,80,5D,9F), V(7C,93,D0,69), V(A9,2D,D5,6F), V(B3,12,25,CF), \
+    V(3B,99,AC,C8), V(A7,7D,18,10), V(6E,63,9C,E8), V(7B,BB,3B,DB), \
+    V(09,78,26,CD), V(F4,18,59,6E), V(01,B7,9A,EC), V(A8,9A,4F,83), \
+    V(65,6E,95,E6), V(7E,E6,FF,AA), V(08,CF,BC,21), V(E6,E8,15,EF), \
+    V(D9,9B,E7,BA), V(CE,36,6F,4A), V(D4,09,9F,EA), V(D6,7C,B0,29), \
+    V(AF,B2,A4,31), V(31,23,3F,2A), V(30,94,A5,C6), V(C0,66,A2,35), \
+    V(37,BC,4E,74), V(A6,CA,82,FC), V(B0,D0,90,E0), V(15,D8,A7,33), \
+    V(4A,98,04,F1), V(F7,DA,EC,41), V(0E,50,CD,7F), V(2F,F6,91,17), \
+    V(8D,D6,4D,76), V(4D,B0,EF,43), V(54,4D,AA,CC), V(DF,04,96,E4), \
+    V(E3,B5,D1,9E), V(1B,88,6A,4C), V(B8,1F,2C,C1), V(7F,51,65,46), \
+    V(04,EA,5E,9D), V(5D,35,8C,01), V(73,74,87,FA), V(2E,41,0B,FB), \
+    V(5A,1D,67,B3), V(52,D2,DB,92), V(33,56,10,E9), V(13,47,D6,6D), \
+    V(8C,61,D7,9A), V(7A,0C,A1,37), V(8E,14,F8,59), V(89,3C,13,EB), \
+    V(EE,27,A9,CE), V(35,C9,61,B7), V(ED,E5,1C,E1), V(3C,B1,47,7A), \
+    V(59,DF,D2,9C), V(3F,73,F2,55), V(79,CE,14,18), V(BF,37,C7,73), \
+    V(EA,CD,F7,53), V(5B,AA,FD,5F), V(14,6F,3D,DF), V(86,DB,44,78), \
+    V(81,F3,AF,CA), V(3E,C4,68,B9), V(2C,34,24,38), V(5F,40,A3,C2), \
+    V(72,C3,1D,16), V(0C,25,E2,BC), V(8B,49,3C,28), V(41,95,0D,FF), \
+    V(71,01,A8,39), V(DE,B3,0C,08), V(9C,E4,B4,D8), V(90,C1,56,64), \
+    V(61,84,CB,7B), V(70,B6,32,D5), V(74,5C,6C,48), V(42,57,B8,D0)
+
+#define V(a,b,c,d) 0x##a##b##c##d
+static const uint32_t RT0[256] = { RT };
+#undef V
+
+#define V(a,b,c,d) 0x##b##c##d##a
+static const uint32_t RT1[256] = { RT };
+#undef V
+
+#define V(a,b,c,d) 0x##c##d##a##b
+static const uint32_t RT2[256] = { RT };
+#undef V
+
+#define V(a,b,c,d) 0x##d##a##b##c
+static const uint32_t RT3[256] = { RT };
+#undef V
+
+#undef RT
+
+/*
+ * Round constants
+ */
+static const uint32_t RCON[10] =
+{
+    0x00000001, 0x00000002, 0x00000004, 0x00000008,
+    0x00000010, 0x00000020, 0x00000040, 0x00000080,
+    0x0000001B, 0x00000036
+};
+
+#else
+
+/*
+ * Forward S-box & tables
+ */
+static unsigned char FSb[256];
+static uint32_t FT0[256]; 
+static uint32_t FT1[256]; 
+static uint32_t FT2[256]; 
+static uint32_t FT3[256]; 
+
+/*
+ * Reverse S-box & tables
+ */
+static unsigned char RSb[256];
+static uint32_t RT0[256];
+static uint32_t RT1[256];
+static uint32_t RT2[256];
+static uint32_t RT3[256];
+
+/*
+ * Round constants
+ */
+static uint32_t RCON[10];
+
+/*
+ * Tables generation code
+ */
+#define ROTL8(x) ( ( x << 8 ) & 0xFFFFFFFF ) | ( x >> 24 )
+#define XTIME(x) ( ( x << 1 ) ^ ( ( x & 0x80 ) ? 0x1B : 0x00 ) )
+#define MUL(x,y) ( ( x && y ) ? pow[(log[x]+log[y]) % 255] : 0 )
+
+static int aes_init_done = 0;
+
+static void aes_gen_tables( void )
+{
+    int i, x, y, z;
+    int pow[256];
+    int log[256];
+
+    /*
+     * compute pow and log tables over GF(2^8)
+     */
+    for( i = 0, x = 1; i < 256; i++ )
+    {
+        pow[i] = x;
+        log[x] = i;
+        x = ( x ^ XTIME( x ) ) & 0xFF;
+    }
+
+    /*
+     * calculate the round constants
+     */
+    for( i = 0, x = 1; i < 10; i++ )
+    {
+        RCON[i] = (uint32_t) x;
+        x = XTIME( x ) & 0xFF;
+    }
+
+    /*
+     * generate the forward and reverse S-boxes
+     */
+    FSb[0x00] = 0x63;
+    RSb[0x63] = 0x00;
+
+    for( i = 1; i < 256; i++ )
+    {
+        x = pow[255 - log[i]];
+
+        y  = x; y = ( (y << 1) | (y >> 7) ) & 0xFF;
+        x ^= y; y = ( (y << 1) | (y >> 7) ) & 0xFF;
+        x ^= y; y = ( (y << 1) | (y >> 7) ) & 0xFF;
+        x ^= y; y = ( (y << 1) | (y >> 7) ) & 0xFF;
+        x ^= y ^ 0x63;
+
+        FSb[i] = (unsigned char) x;
+        RSb[x] = (unsigned char) i;
+    }
+
+    /*
+     * generate the forward and reverse tables
+     */
+    for( i = 0; i < 256; i++ )
+    {
+        x = FSb[i];
+        y = XTIME( x ) & 0xFF;
+        z =  ( y ^ x ) & 0xFF;
+
+        FT0[i] = ( (uint32_t) y       ) ^
+                 ( (uint32_t) x <<  8 ) ^
+                 ( (uint32_t) x << 16 ) ^
+                 ( (uint32_t) z << 24 );
+
+        FT1[i] = ROTL8( FT0[i] );
+        FT2[i] = ROTL8( FT1[i] );
+        FT3[i] = ROTL8( FT2[i] );
+
+        x = RSb[i];
+
+        RT0[i] = ( (uint32_t) MUL( 0x0E, x )       ) ^
+                 ( (uint32_t) MUL( 0x09, x ) <<  8 ) ^
+                 ( (uint32_t) MUL( 0x0D, x ) << 16 ) ^
+                 ( (uint32_t) MUL( 0x0B, x ) << 24 );
+
+        RT1[i] = ROTL8( RT0[i] );
+        RT2[i] = ROTL8( RT1[i] );
+        RT3[i] = ROTL8( RT2[i] );
+    }
+}
+
+#endif
+
+/*
+ * AES key schedule (encryption)
+ */
+int aes_setkey_enc( aes_context *ctx, const unsigned char *key, unsigned int keysize )
+{
+    unsigned int i;
+    uint32_t *RK;
+
+#if !defined(POLARSSL_AES_ROM_TABLES)
+    if( aes_init_done == 0 )
+    {
+        aes_gen_tables();
+        aes_init_done = 1;
+
+    }
+#endif
+
+    switch( keysize )
+    {
+        case 128: ctx->nr = 10; break;
+        case 192: ctx->nr = 12; break;
+        case 256: ctx->nr = 14; break;
+        default : return( POLARSSL_ERR_AES_INVALID_KEY_LENGTH );
+    }
+
+    ctx->rk = RK = ctx->buf;
+
+    for( i = 0; i < (keysize >> 5); i++ )
+    {
+        GET_UINT32_LE( RK[i], key, i << 2 );
+    }
+
+    switch( ctx->nr )
+    {
+        case 10:
+
+            for( i = 0; i < 10; i++, RK += 4 )
+            {
+                RK[4]  = RK[0] ^ RCON[i] ^
+                ( (uint32_t) FSb[ ( RK[3] >>  8 ) & 0xFF ]       ) ^
+                ( (uint32_t) FSb[ ( RK[3] >> 16 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) FSb[ ( RK[3] >> 24 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) FSb[ ( RK[3]       ) & 0xFF ] << 24 );
+
+                RK[5]  = RK[1] ^ RK[4];
+                RK[6]  = RK[2] ^ RK[5];
+                RK[7]  = RK[3] ^ RK[6];
+            }
+            break;
+
+        case 12:
+
+            for( i = 0; i < 8; i++, RK += 6 )
+            {
+                RK[6]  = RK[0] ^ RCON[i] ^
+                ( (uint32_t) FSb[ ( RK[5] >>  8 ) & 0xFF ]       ) ^
+                ( (uint32_t) FSb[ ( RK[5] >> 16 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) FSb[ ( RK[5] >> 24 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) FSb[ ( RK[5]       ) & 0xFF ] << 24 );
+
+                RK[7]  = RK[1] ^ RK[6];
+                RK[8]  = RK[2] ^ RK[7];
+                RK[9]  = RK[3] ^ RK[8];
+                RK[10] = RK[4] ^ RK[9];
+                RK[11] = RK[5] ^ RK[10];
+            }
+            break;
+
+        case 14:
+
+            for( i = 0; i < 7; i++, RK += 8 )
+            {
+                RK[8]  = RK[0] ^ RCON[i] ^
+                ( (uint32_t) FSb[ ( RK[7] >>  8 ) & 0xFF ]       ) ^
+                ( (uint32_t) FSb[ ( RK[7] >> 16 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) FSb[ ( RK[7] >> 24 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) FSb[ ( RK[7]       ) & 0xFF ] << 24 );
+
+                RK[9]  = RK[1] ^ RK[8];
+                RK[10] = RK[2] ^ RK[9];
+                RK[11] = RK[3] ^ RK[10];
+
+                RK[12] = RK[4] ^
+                ( (uint32_t) FSb[ ( RK[11]       ) & 0xFF ]       ) ^
+                ( (uint32_t) FSb[ ( RK[11] >>  8 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) FSb[ ( RK[11] >> 16 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) FSb[ ( RK[11] >> 24 ) & 0xFF ] << 24 );
+
+                RK[13] = RK[5] ^ RK[12];
+                RK[14] = RK[6] ^ RK[13];
+                RK[15] = RK[7] ^ RK[14];
+            }
+            break;
+
+        default:
+
+            break;
+    }
+
+    return( 0 );
+}
+
+/*
+ * AES key schedule (decryption)
+ */
+int aes_setkey_dec( aes_context *ctx, const unsigned char *key, unsigned int keysize )
+{
+    int i, j;
+    aes_context cty;
+    uint32_t *RK;
+    uint32_t *SK;
+    int ret;
+
+    switch( keysize )
+    {
+        case 128: ctx->nr = 10; break;
+        case 192: ctx->nr = 12; break;
+        case 256: ctx->nr = 14; break;
+        default : return( POLARSSL_ERR_AES_INVALID_KEY_LENGTH );
+    }
+
+    ctx->rk = RK = ctx->buf;
+
+    ret = aes_setkey_enc( &cty, key, keysize );
+    if( ret != 0 )
+        return( ret );
+
+    SK = cty.rk + cty.nr * 4;
+
+    *RK++ = *SK++;
+    *RK++ = *SK++;
+    *RK++ = *SK++;
+    *RK++ = *SK++;
+
+    for( i = ctx->nr - 1, SK -= 8; i > 0; i--, SK -= 8 )
+    {
+        for( j = 0; j < 4; j++, SK++ )
+        {
+            *RK++ = RT0[ FSb[ ( *SK       ) & 0xFF ] ] ^
+                    RT1[ FSb[ ( *SK >>  8 ) & 0xFF ] ] ^
+                    RT2[ FSb[ ( *SK >> 16 ) & 0xFF ] ] ^
+                    RT3[ FSb[ ( *SK >> 24 ) & 0xFF ] ];
+        }
+    }
+
+    *RK++ = *SK++;
+    *RK++ = *SK++;
+    *RK++ = *SK++;
+    *RK++ = *SK++;
+
+    memset( &cty, 0, sizeof( aes_context ) );
+
+    return( 0 );
+}
+
+#define AES_FROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3)     \
+{                                               \
+    X0 = *RK++ ^ FT0[ ( Y0       ) & 0xFF ] ^   \
+                 FT1[ ( Y1 >>  8 ) & 0xFF ] ^   \
+                 FT2[ ( Y2 >> 16 ) & 0xFF ] ^   \
+                 FT3[ ( Y3 >> 24 ) & 0xFF ];    \
+                                                \
+    X1 = *RK++ ^ FT0[ ( Y1       ) & 0xFF ] ^   \
+                 FT1[ ( Y2 >>  8 ) & 0xFF ] ^   \
+                 FT2[ ( Y3 >> 16 ) & 0xFF ] ^   \
+                 FT3[ ( Y0 >> 24 ) & 0xFF ];    \
+                                                \
+    X2 = *RK++ ^ FT0[ ( Y2       ) & 0xFF ] ^   \
+                 FT1[ ( Y3 >>  8 ) & 0xFF ] ^   \
+                 FT2[ ( Y0 >> 16 ) & 0xFF ] ^   \
+                 FT3[ ( Y1 >> 24 ) & 0xFF ];    \
+                                                \
+    X3 = *RK++ ^ FT0[ ( Y3       ) & 0xFF ] ^   \
+                 FT1[ ( Y0 >>  8 ) & 0xFF ] ^   \
+                 FT2[ ( Y1 >> 16 ) & 0xFF ] ^   \
+                 FT3[ ( Y2 >> 24 ) & 0xFF ];    \
+}
+
+#define AES_RROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3)     \
+{                                               \
+    X0 = *RK++ ^ RT0[ ( Y0       ) & 0xFF ] ^   \
+                 RT1[ ( Y3 >>  8 ) & 0xFF ] ^   \
+                 RT2[ ( Y2 >> 16 ) & 0xFF ] ^   \
+                 RT3[ ( Y1 >> 24 ) & 0xFF ];    \
+                                                \
+    X1 = *RK++ ^ RT0[ ( Y1       ) & 0xFF ] ^   \
+                 RT1[ ( Y0 >>  8 ) & 0xFF ] ^   \
+                 RT2[ ( Y3 >> 16 ) & 0xFF ] ^   \
+                 RT3[ ( Y2 >> 24 ) & 0xFF ];    \
+                                                \
+    X2 = *RK++ ^ RT0[ ( Y2       ) & 0xFF ] ^   \
+                 RT1[ ( Y1 >>  8 ) & 0xFF ] ^   \
+                 RT2[ ( Y0 >> 16 ) & 0xFF ] ^   \
+                 RT3[ ( Y3 >> 24 ) & 0xFF ];    \
+                                                \
+    X3 = *RK++ ^ RT0[ ( Y3       ) & 0xFF ] ^   \
+                 RT1[ ( Y2 >>  8 ) & 0xFF ] ^   \
+                 RT2[ ( Y1 >> 16 ) & 0xFF ] ^   \
+                 RT3[ ( Y0 >> 24 ) & 0xFF ];    \
+}
+
+/*
+ * AES-ECB block encryption/decryption
+ */
+int aes_crypt_ecb( aes_context *ctx,
+                    int mode,
+                    const unsigned char input[16],
+                    unsigned char output[16] )
+{
+    int i;
+    uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3;
+
+    RK = ctx->rk;
+
+    GET_UINT32_LE( X0, input,  0 ); X0 ^= *RK++;
+    GET_UINT32_LE( X1, input,  4 ); X1 ^= *RK++;
+    GET_UINT32_LE( X2, input,  8 ); X2 ^= *RK++;
+    GET_UINT32_LE( X3, input, 12 ); X3 ^= *RK++;
+
+    if( mode == AES_DECRYPT )
+    {
+        for( i = (ctx->nr >> 1) - 1; i > 0; i-- )
+        {
+            AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
+            AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
+        }
+
+        AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
+
+        X0 = *RK++ ^ \
+                ( (uint32_t) RSb[ ( Y0       ) & 0xFF ]       ) ^
+                ( (uint32_t) RSb[ ( Y3 >>  8 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) RSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) RSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
+
+        X1 = *RK++ ^ \
+                ( (uint32_t) RSb[ ( Y1       ) & 0xFF ]       ) ^
+                ( (uint32_t) RSb[ ( Y0 >>  8 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) RSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) RSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
+
+        X2 = *RK++ ^ \
+                ( (uint32_t) RSb[ ( Y2       ) & 0xFF ]       ) ^
+                ( (uint32_t) RSb[ ( Y1 >>  8 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) RSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) RSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
+
+        X3 = *RK++ ^ \
+                ( (uint32_t) RSb[ ( Y3       ) & 0xFF ]       ) ^
+                ( (uint32_t) RSb[ ( Y2 >>  8 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) RSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) RSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
+    }
+    else /* AES_ENCRYPT */
+    {
+        for( i = (ctx->nr >> 1) - 1; i > 0; i-- )
+        {
+            AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
+            AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 );
+        }
+
+        AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 );
+
+        X0 = *RK++ ^ \
+                ( (uint32_t) FSb[ ( Y0       ) & 0xFF ]       ) ^
+                ( (uint32_t) FSb[ ( Y1 >>  8 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) FSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) FSb[ ( Y3 >> 24 ) & 0xFF ] << 24 );
+
+        X1 = *RK++ ^ \
+                ( (uint32_t) FSb[ ( Y1       ) & 0xFF ]       ) ^
+                ( (uint32_t) FSb[ ( Y2 >>  8 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) FSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) FSb[ ( Y0 >> 24 ) & 0xFF ] << 24 );
+
+        X2 = *RK++ ^ \
+                ( (uint32_t) FSb[ ( Y2       ) & 0xFF ]       ) ^
+                ( (uint32_t) FSb[ ( Y3 >>  8 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) FSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) FSb[ ( Y1 >> 24 ) & 0xFF ] << 24 );
+
+        X3 = *RK++ ^ \
+                ( (uint32_t) FSb[ ( Y3       ) & 0xFF ]       ) ^
+                ( (uint32_t) FSb[ ( Y0 >>  8 ) & 0xFF ] <<  8 ) ^
+                ( (uint32_t) FSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^
+                ( (uint32_t) FSb[ ( Y2 >> 24 ) & 0xFF ] << 24 );
+    }
+
+    PUT_UINT32_LE( X0, output,  0 );
+    PUT_UINT32_LE( X1, output,  4 );
+    PUT_UINT32_LE( X2, output,  8 );
+    PUT_UINT32_LE( X3, output, 12 );
+
+    return( 0 );
+}
+
+/*
+ * AES-CBC buffer encryption/decryption
+ */
+int aes_crypt_cbc( aes_context *ctx,
+                    int mode,
+                    size_t length,
+                    unsigned char iv[16],
+                    const unsigned char *input,
+                    unsigned char *output )
+{
+    int i;
+    unsigned char temp[16];
+
+    if( length % 16 )
+        return( POLARSSL_ERR_AES_INVALID_INPUT_LENGTH );
+
+    if( mode == AES_DECRYPT )
+    {
+        while( length > 0 )
+        {
+            memcpy( temp, input, 16 );
+            aes_crypt_ecb( ctx, mode, input, output );
+
+            for( i = 0; i < 16; i++ )
+                output[i] = (unsigned char)( output[i] ^ iv[i] );
+
+            memcpy( iv, temp, 16 );
+
+            input  += 16;
+            output += 16;
+            length -= 16;
+        }
+    }
+    else
+    {
+        while( length > 0 )
+        {
+            for( i = 0; i < 16; i++ )
+                output[i] = (unsigned char)( input[i] ^ iv[i] );
+
+            aes_crypt_ecb( ctx, mode, output, output );
+            memcpy( iv, output, 16 );
+
+            input  += 16;
+            output += 16;
+            length -= 16;
+        }
+    }
+
+    return( 0 );
+}
+
+/*
+ * AES-CFB128 buffer encryption/decryption
+ */
+int aes_crypt_cfb128( aes_context *ctx,
+                       int mode,
+                       size_t length,
+                       size_t *iv_off,
+                       unsigned char iv[16],
+                       const unsigned char *input,
+                       unsigned char *output )
+{
+    int c;
+    size_t n = *iv_off;
+
+    if( mode == AES_DECRYPT )
+    {
+        while( length-- )
+        {
+            if( n == 0 )
+                aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );
+
+            c = *input++;
+            *output++ = (unsigned char)( c ^ iv[n] );
+            iv[n] = (unsigned char) c;
+
+            n = (n + 1) & 0x0F;
+        }
+    }
+    else
+    {
+        while( length-- )
+        {
+            if( n == 0 )
+                aes_crypt_ecb( ctx, AES_ENCRYPT, iv, iv );
+
+            iv[n] = *output++ = (unsigned char)( iv[n] ^ *input++ );
+
+            n = (n + 1) & 0x0F;
+        }
+    }
+
+    *iv_off = n;
+
+    return( 0 );
+}
+
+/*
+ * AES-CTR buffer encryption/decryption
+ */
+int aes_crypt_ctr( aes_context *ctx,
+                       size_t length,
+                       size_t *nc_off,
+                       unsigned char nonce_counter[16],
+                       unsigned char stream_block[16],
+                       const unsigned char *input,
+                       unsigned char *output )
+{
+    int c, i;
+    size_t n = *nc_off;
+
+    while( length-- )
+    {
+        if( n == 0 ) {
+            aes_crypt_ecb( ctx, AES_ENCRYPT, nonce_counter, stream_block );
+
+            for( i = 16; i > 0; i-- )
+                if( ++nonce_counter[i - 1] != 0 )
+                    break;
+        }
+        c = *input++;
+        *output++ = (unsigned char)( c ^ stream_block[n] );
+
+        n = (n + 1) & 0x0F;
+    }
+
+    *nc_off = n;
+
+    return( 0 );
+}
+
+/* AES-CMAC */
+
+unsigned char const_Rb[16] = {
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x87
+};
+unsigned char const_Zero[16] = {
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+void leftshift_onebit(unsigned char *input, unsigned char *output)
+{
+	int i;
+    unsigned char overflow = 0;
+
+	for (i = 15; i >= 0; i--) 
+	{
+		output[i] = input[i] << 1;
+		output[i] |= overflow;
+		overflow = (input[i] & 0x80) ? 1 : 0;
+	}
+}
+
+void xor_128(unsigned char *a, unsigned char *b, unsigned char *out)
+{
+	int i;
+	for (i = 0; i < 16; i++) 
+		out[i] = a[i] ^ b[i];
+}
+
+void generate_subkey(aes_context *ctx, unsigned char *K1, unsigned char *K2)
+{
+	unsigned char L[16];
+	unsigned char Z[16];
+	unsigned char tmp[16];
+	
+	int i;
+	for (i = 0; i < 16; i++) Z[i] = 0;
+
+	aes_crypt_ecb(ctx, AES_ENCRYPT, Z, L);
+
+	if ((L[0] & 0x80) == 0)
+	{
+		leftshift_onebit(L,K1);
+	} else {
+        leftshift_onebit(L,tmp);
+        xor_128(tmp,const_Rb,K1);
+    }
+
+	if ((K1[0] & 0x80) == 0) 
+	{
+        leftshift_onebit(K1,K2);
+    } else {
+        leftshift_onebit(K1,tmp);
+        xor_128(tmp,const_Rb,K2);
+    }
+}
+
+void padding (unsigned char *lastb, unsigned char *pad, int length)
+{
+	int i;
+	for (i = 0; i < 16; i++) 
+	{
+		if (i < length) 
+			pad[i] = lastb[i];
+        else if (i == length)
+            pad[i] = 0x80;
+        else
+            pad[i] = 0x00;
+	}
+}
+
+void aes_cmac(aes_context *ctx, int length, unsigned char *input, unsigned char *output)
+{
+    unsigned char X[16], Y[16], M_last[16], padded[16];
+    unsigned char K1[16], K2[16];
+    int n, i, flag;
+    generate_subkey(ctx, K1, K2);
+
+    n = (length + 15) / 16;
+    if (n == 0) 
+	{
+        n = 1;
+        flag = 0;
+    } else {
+		if ((length % 16) == 0)
+            flag = 1;
+		else
+			flag = 0;
+    }
+
+    if (flag) 
+	{
+        xor_128(&input[16 * (n - 1)], K1, M_last);
+    } else {
+        padding(&input[16 * (n - 1)], padded, length % 16);
+        xor_128(padded, K2, M_last);
+    }
+
+    for (i = 0; i < 16; i++) X[i] = 0;
+    for (i = 0; i < n - 1; i++) 
+    {
+        xor_128(X, &input[16*i], Y);
+		aes_crypt_ecb(ctx, AES_ENCRYPT, Y, X); 
+    }
+
+    xor_128(X,M_last,Y);
+    aes_crypt_ecb(ctx, AES_ENCRYPT, Y, X);
+
+    for (i = 0; i < 16; i++)
+		output[i] = X[i];
+}

rpcs3/Crypto/aes.h

@@ -0,0 +1,179 @@
+#pragma once
+
+/**
+ * \file aes.h
+ *
+ * \brief AES block cipher
+ *
+ *  Copyright (C) 2006-2013, Brainspark B.V.
+ *
+ *  This file is part of PolarSSL (http://www.polarssl.org)
+ *  Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
+ *
+ *  All rights reserved.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  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 for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include <string.h>
+
+#ifdef _MSC_VER
+#include <basetsd.h>
+typedef UINT32 uint32_t;
+#else
+#include <inttypes.h>
+#endif
+
+#define AES_ENCRYPT     1
+#define AES_DECRYPT     0
+
+#define POLARSSL_ERR_AES_INVALID_KEY_LENGTH                -0x0020  /**< Invalid key length. */
+#define POLARSSL_ERR_AES_INVALID_INPUT_LENGTH              -0x0022  /**< Invalid data input length. */
+
+// Regular implementation
+//
+
+/**
+ * \brief          AES context structure
+ */
+typedef struct
+{
+    int nr;                     /*!<  number of rounds  */
+    uint32_t *rk;               /*!<  AES round keys    */
+    uint32_t buf[68];           /*!<  unaligned data    */
+}
+aes_context;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \brief          AES key schedule (encryption)
+ *
+ * \param ctx      AES context to be initialized
+ * \param key      encryption key
+ * \param keysize  must be 128, 192 or 256
+ *
+ * \return         0 if successful, or POLARSSL_ERR_AES_INVALID_KEY_LENGTH
+ */
+int aes_setkey_enc( aes_context *ctx, const unsigned char *key, unsigned int keysize );
+
+/**
+ * \brief          AES key schedule (decryption)
+ *
+ * \param ctx      AES context to be initialized
+ * \param key      decryption key
+ * \param keysize  must be 128, 192 or 256
+ *
+ * \return         0 if successful, or POLARSSL_ERR_AES_INVALID_KEY_LENGTH
+ */
+int aes_setkey_dec( aes_context *ctx, const unsigned char *key, unsigned int keysize );
+
+/**
+ * \brief          AES-ECB block encryption/decryption
+ *
+ * \param ctx      AES context
+ * \param mode     AES_ENCRYPT or AES_DECRYPT
+ * \param input    16-byte input block
+ * \param output   16-byte output block
+ *
+ * \return         0 if successful
+ */
+int aes_crypt_ecb( aes_context *ctx,
+                    int mode,
+                    const unsigned char input[16],
+                    unsigned char output[16] );
+
+/**
+ * \brief          AES-CBC buffer encryption/decryption
+ *                 Length should be a multiple of the block
+ *                 size (16 bytes)
+ *
+ * \param ctx      AES context
+ * \param mode     AES_ENCRYPT or AES_DECRYPT
+ * \param length   length of the input data
+ * \param iv       initialization vector (updated after use)
+ * \param input    buffer holding the input data
+ * \param output   buffer holding the output data
+ *
+ * \return         0 if successful, or POLARSSL_ERR_AES_INVALID_INPUT_LENGTH
+ */
+int aes_crypt_cbc( aes_context *ctx,
+                    int mode,
+                    size_t length,
+                    unsigned char iv[16],
+                    const unsigned char *input,
+                    unsigned char *output );
+
+/**
+ * \brief          AES-CFB128 buffer encryption/decryption.
+ *
+ * Note: Due to the nature of CFB you should use the same key schedule for
+ * both encryption and decryption. So a context initialized with
+ * aes_setkey_enc() for both AES_ENCRYPT and AES_DECRYPT.
+ *
+ * both 
+ * \param ctx      AES context
+ * \param mode     AES_ENCRYPT or AES_DECRYPT
+ * \param length   length of the input data
+ * \param iv_off   offset in IV (updated after use)
+ * \param iv       initialization vector (updated after use)
+ * \param input    buffer holding the input data
+ * \param output   buffer holding the output data
+ *
+ * \return         0 if successful
+ */
+int aes_crypt_cfb128( aes_context *ctx,
+                       int mode,
+                       size_t length,
+                       size_t *iv_off,
+                       unsigned char iv[16],
+                       const unsigned char *input,
+                       unsigned char *output );
+
+/**
+ * \brief               AES-CTR buffer encryption/decryption
+ *
+ * Warning: You have to keep the maximum use of your counter in mind!
+ *
+ * Note: Due to the nature of CTR you should use the same key schedule for
+ * both encryption and decryption. So a context initialized with
+ * aes_setkey_enc() for both AES_ENCRYPT and AES_DECRYPT.
+ *
+ * \param length        The length of the data
+ * \param nc_off        The offset in the current stream_block (for resuming
+ *                      within current cipher stream). The offset pointer to
+ *                      should be 0 at the start of a stream.
+ * \param nonce_counter The 128-bit nonce and counter.
+ * \param stream_block  The saved stream-block for resuming. Is overwritten
+ *                      by the function.
+ * \param input         The input data stream
+ * \param output        The output data stream
+ *
+ * \return         0 if successful
+ */
+int aes_crypt_ctr( aes_context *ctx,
+                       size_t length,
+                       size_t *nc_off,
+                       unsigned char nonce_counter[16],
+                       unsigned char stream_block[16],
+                       const unsigned char *input,
+                       unsigned char *output );
+
+void aes_cmac(aes_context *ctx, int length, unsigned char *input, unsigned char *output);
+
+#ifdef __cplusplus
+}
+#endif

rpcs3/Crypto/ec.cpp

@@ -0,0 +1,548 @@
+// Copyright 2007,2008,2010  Segher Boessenkool  <segher@kernel.crashing.org>
+// Licensed under the terms of the GNU GPL, version 2
+// http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
+
+#include "stdafx.h"
+#include "utils.h"
+
+void bn_print(char *name, u8 *a, u32 n)
+{
+	u32 i;
+
+	printf("%s = ", name);
+
+	for (i = 0; i < n; i++)
+		printf("%02x", a[i]);
+
+	printf("\n");
+}
+
+static void bn_zero(u8 *d, u32 n)
+{
+	memset(d, 0, n);
+}
+void bn_copy(u8 *d, u8 *a, u32 n)
+{
+	memcpy(d, a, n);
+}
+
+int bn_compare(u8 *a, u8 *b, u32 n)
+{
+	u32 i;
+
+	for (i = 0; i < n; i++) {
+		if (a[i] < b[i])
+			return -1;
+		if (a[i] > b[i])
+			return 1;
+	}
+
+	return 0;
+}
+
+static u8 bn_add_1(u8 *d, u8 *a, u8 *b, u32 n)
+{
+	u32 i;
+	u32 dig;
+	u8 c;
+
+	c = 0;
+	for (i = n - 1; i < n; i--) {
+		dig = a[i] + b[i] + c;
+		c = dig >> 8;
+		d[i] = dig;
+	}
+
+	return c;
+}
+
+static u8 bn_sub_1(u8 *d, u8 *a, u8 *b, u32 n)
+{
+	u32 i;
+	u32 dig;
+	u8 c;
+
+	c = 1;
+	for (i = n - 1; i < n; i--) {
+		dig = a[i] + 255 - b[i] + c;
+		c = dig >> 8;
+		d[i] = dig;
+	}
+
+	return 1 - c;
+}
+
+void bn_reduce(u8 *d, u8 *N, u32 n)
+{
+	if (bn_compare(d, N, n) >= 0)
+		bn_sub_1(d, d, N, n);
+}
+
+void bn_add(u8 *d, u8 *a, u8 *b, u8 *N, u32 n)
+{
+	if (bn_add_1(d, a, b, n))
+		bn_sub_1(d, d, N, n);
+
+	bn_reduce(d, N, n);
+}
+
+void bn_sub(u8 *d, u8 *a, u8 *b, u8 *N, u32 n)
+{
+	if (bn_sub_1(d, a, b, n))
+		bn_add_1(d, d, N, n);
+}
+
+static const u8 inv256[0x80] = {
+	0x01, 0xab, 0xcd, 0xb7, 0x39, 0xa3, 0xc5, 0xef,
+	0xf1, 0x1b, 0x3d, 0xa7, 0x29, 0x13, 0x35, 0xdf,
+	0xe1, 0x8b, 0xad, 0x97, 0x19, 0x83, 0xa5, 0xcf,
+	0xd1, 0xfb, 0x1d, 0x87, 0x09, 0xf3, 0x15, 0xbf,
+	0xc1, 0x6b, 0x8d, 0x77, 0xf9, 0x63, 0x85, 0xaf,
+	0xb1, 0xdb, 0xfd, 0x67, 0xe9, 0xd3, 0xf5, 0x9f,
+	0xa1, 0x4b, 0x6d, 0x57, 0xd9, 0x43, 0x65, 0x8f,
+	0x91, 0xbb, 0xdd, 0x47, 0xc9, 0xb3, 0xd5, 0x7f,
+	0x81, 0x2b, 0x4d, 0x37, 0xb9, 0x23, 0x45, 0x6f,
+	0x71, 0x9b, 0xbd, 0x27, 0xa9, 0x93, 0xb5, 0x5f,
+	0x61, 0x0b, 0x2d, 0x17, 0x99, 0x03, 0x25, 0x4f,
+	0x51, 0x7b, 0x9d, 0x07, 0x89, 0x73, 0x95, 0x3f,
+	0x41, 0xeb, 0x0d, 0xf7, 0x79, 0xe3, 0x05, 0x2f,
+	0x31, 0x5b, 0x7d, 0xe7, 0x69, 0x53, 0x75, 0x1f,
+	0x21, 0xcb, 0xed, 0xd7, 0x59, 0xc3, 0xe5, 0x0f,
+	0x11, 0x3b, 0x5d, 0xc7, 0x49, 0x33, 0x55, 0xff,
+};
+
+static void bn_mon_muladd_dig(u8 *d, u8 *a, u8 b, u8 *N, u32 n)
+{
+	u32 dig;
+	u32 i;
+
+	u8 z = -(d[n-1] + a[n-1]*b) * inv256[N[n-1]/2];
+
+	dig = d[n-1] + a[n-1]*b + N[n-1]*z;
+	dig >>= 8;
+
+	for (i = n - 2; i < n; i--) {
+		dig += d[i] + a[i]*b + N[i]*z;
+		d[i+1] = dig;
+		dig >>= 8;
+	}
+
+	d[0] = dig;
+	dig >>= 8;
+
+	if (dig)
+		bn_sub_1(d, d, N, n);
+
+	bn_reduce(d, N, n);
+}
+
+void bn_mon_mul(u8 *d, u8 *a, u8 *b, u8 *N, u32 n)
+{
+	u8 t[512];
+	u32 i;
+
+	bn_zero(t, n);
+
+	for (i = n - 1; i < n; i--)
+		bn_mon_muladd_dig(t, a, b[i], N, n);
+
+	bn_copy(d, t, n);
+}
+
+void bn_to_mon(u8 *d, u8 *N, u32 n)
+{
+	u32 i;
+
+	for (i = 0; i < 8*n; i++)
+		bn_add(d, d, d, N, n);
+}
+
+void bn_from_mon(u8 *d, u8 *N, u32 n)
+{
+	u8 t[512];
+
+	bn_zero(t, n);
+	t[n-1] = 1;
+	bn_mon_mul(d, d, t, N, n);
+}
+
+static void bn_mon_exp(u8 *d, u8 *a, u8 *N, u32 n, u8 *e, u32 en)
+{
+	u8 t[512];
+	u32 i;
+	u8 mask;
+
+	bn_zero(d, n);
+	d[n-1] = 1;
+	bn_to_mon(d, N, n);
+
+	for (i = 0; i < en; i++)
+		for (mask = 0x80; mask != 0; mask >>= 1) {
+			bn_mon_mul(t, d, d, N, n);
+			if ((e[i] & mask) != 0)
+				bn_mon_mul(d, t, a, N, n);
+			else
+				bn_copy(d, t, n);
+		}
+}
+
+void bn_mon_inv(u8 *d, u8 *a, u8 *N, u32 n)
+{
+	u8 t[512], s[512];
+
+	bn_zero(s, n);
+	s[n-1] = 2;
+	bn_sub_1(t, N, s, n);
+	bn_mon_exp(d, a, N, n, t, n);
+}
+
+void bn_copy(u8 *d, u8 *a, u32 n);
+int bn_compare(u8 *a, u8 *b, u32 n);
+void bn_reduce(u8 *d, u8 *N, u32 n);
+void bn_add(u8 *d, u8 *a, u8 *b, u8 *N, u32 n);
+void bn_sub(u8 *d, u8 *a, u8 *b, u8 *N, u32 n);
+void bn_to_mon(u8 *d, u8 *N, u32 n);
+void bn_from_mon(u8 *d, u8 *N, u32 n);
+void bn_mon_mul(u8 *d, u8 *a, u8 *b, u8 *N, u32 n);
+void bn_mon_inv(u8 *d, u8 *a, u8 *N, u32 n);
+
+struct point {
+	u8 x[20];
+	u8 y[20];
+};
+
+static u8 ec_p[20];
+static u8 ec_a[20];	// mon
+static u8 ec_b[20];	// mon
+static u8 ec_N[21];
+static struct point ec_G;	// mon
+static struct point ec_Q;	// mon
+static u8 ec_k[21];
+
+static void elt_copy(u8 *d, u8 *a)
+{
+	memcpy(d, a, 20);
+}
+
+static void elt_zero(u8 *d)
+{
+	memset(d, 0, 20);
+}
+
+static int elt_is_zero(u8 *d)
+{
+	u32 i;
+
+	for (i = 0; i < 20; i++)
+		if (d[i] != 0)
+			return 0;
+
+	return 1;
+}
+
+static void elt_add(u8 *d, u8 *a, u8 *b)
+{
+	bn_add(d, a, b, ec_p, 20);
+}
+
+static void elt_sub(u8 *d, u8 *a, u8 *b)
+{
+	bn_sub(d, a, b, ec_p, 20);
+}
+
+static void elt_mul(u8 *d, u8 *a, u8 *b)
+{
+	bn_mon_mul(d, a, b, ec_p, 20);
+}
+
+static void elt_square(u8 *d, u8 *a)
+{
+	elt_mul(d, a, a);
+}
+
+static void elt_inv(u8 *d, u8 *a)
+{
+	u8 s[20];
+	elt_copy(s, a);
+	bn_mon_inv(d, s, ec_p, 20);
+}
+
+static void point_to_mon(struct point *p)
+{
+	bn_to_mon(p->x, ec_p, 20);
+	bn_to_mon(p->y, ec_p, 20);
+}
+
+static void point_from_mon(struct point *p)
+{
+	bn_from_mon(p->x, ec_p, 20);
+	bn_from_mon(p->y, ec_p, 20);
+}
+
+#if 0
+static int point_is_on_curve(u8 *p)
+{
+	u8 s[20], t[20];
+	u8 *x, *y;
+
+	x = p;
+	y = p + 20;
+
+	elt_square(t, x);
+	elt_mul(s, t, x);
+
+	elt_mul(t, x, ec_a);
+	elt_add(s, s, t);
+
+	elt_add(s, s, ec_b);
+
+	elt_square(t, y);
+	elt_sub(s, s, t);
+
+	return elt_is_zero(s);
+}
+#endif
+
+static void point_zero(struct point *p)
+{
+	elt_zero(p->x);
+	elt_zero(p->y);
+}
+
+static int point_is_zero(struct point *p)
+{
+	return elt_is_zero(p->x) && elt_is_zero(p->y);
+}
+
+static void point_double(struct point *r, struct point *p)
+{
+	u8 s[20], t[20];
+	struct point pp;
+	u8 *px, *py, *rx, *ry;
+
+	pp = *p;
+
+	px = pp.x;
+	py = pp.y;
+	rx = r->x;
+	ry = r->y;
+
+	if (elt_is_zero(py)) {
+		point_zero(r);
+		return;
+	}
+
+	elt_square(t, px);	// t = px*px
+	elt_add(s, t, t);	// s = 2*px*px
+	elt_add(s, s, t);	// s = 3*px*px
+	elt_add(s, s, ec_a);	// s = 3*px*px + a
+	elt_add(t, py, py);	// t = 2*py
+	elt_inv(t, t);		// t = 1/(2*py)
+	elt_mul(s, s, t);	// s = (3*px*px+a)/(2*py)
+
+	elt_square(rx, s);	// rx = s*s
+	elt_add(t, px, px);	// t = 2*px
+	elt_sub(rx, rx, t);	// rx = s*s - 2*px
+
+	elt_sub(t, px, rx);	// t = -(rx-px)
+	elt_mul(ry, s, t);	// ry = -s*(rx-px)
+	elt_sub(ry, ry, py);	// ry = -s*(rx-px) - py
+}
+
+static void point_add(struct point *r, struct point *p, struct point *q)
+{
+	u8 s[20], t[20], u[20];
+	u8 *px, *py, *qx, *qy, *rx, *ry;
+	struct point pp, qq;
+
+	pp = *p;
+	qq = *q;
+
+	px = pp.x;
+	py = pp.y;
+	qx = qq.x;
+	qy = qq.y;
+	rx = r->x;
+	ry = r->y;
+
+	if (point_is_zero(&pp)) {
+		elt_copy(rx, qx);
+		elt_copy(ry, qy);
+		return;
+	}
+
+	if (point_is_zero(&qq)) {
+		elt_copy(rx, px);
+		elt_copy(ry, py);
+		return;
+	}
+
+	elt_sub(u, qx, px);
+
+	if (elt_is_zero(u)) {
+		elt_sub(u, qy, py);
+		if (elt_is_zero(u))
+			point_double(r, &pp);
+		else
+			point_zero(r);
+
+		return;
+	}
+
+	elt_inv(t, u);		// t = 1/(qx-px)
+	elt_sub(u, qy, py);	// u = qy-py
+	elt_mul(s, t, u);	// s = (qy-py)/(qx-px)
+
+	elt_square(rx, s);	// rx = s*s
+	elt_add(t, px, qx);	// t = px+qx
+	elt_sub(rx, rx, t);	// rx = s*s - (px+qx)
+
+	elt_sub(t, px, rx);	// t = -(rx-px)
+	elt_mul(ry, s, t);	// ry = -s*(rx-px)
+	elt_sub(ry, ry, py);	// ry = -s*(rx-px) - py
+}
+
+static void point_mul(struct point *d, u8 *a, struct point *b)	// a is bignum
+{
+	u32 i;
+	u8 mask;
+
+	point_zero(d);
+
+	for (i = 0; i < 21; i++)
+		for (mask = 0x80; mask != 0; mask >>= 1) {
+			point_double(d, d);
+			if ((a[i] & mask) != 0)
+				point_add(d, d, b);
+		}
+}
+
+static void generate_ecdsa(u8 *R, u8 *S, u8 *k, u8 *hash)
+{
+	u8 e[21];
+	u8 kk[21];
+	u8 m[21];
+	u8 minv[21];
+	struct point mG;
+
+	e[0] = 0;
+	memcpy(e + 1, hash, 20);
+	bn_reduce(e, ec_N, 21);
+
+try_again:
+	prng(m, 21);
+	m[0] = 0;
+	if (bn_compare(m, ec_N, 21) >= 0)
+		goto try_again;
+
+	//	R = (mG).x
+
+	point_mul(&mG, m, &ec_G);
+	point_from_mon(&mG);
+	R[0] = 0;
+	elt_copy(R+1, mG.x);
+
+	//	S = m**-1*(e + Rk) (mod N)
+
+	bn_copy(kk, k, 21);
+	bn_reduce(kk, ec_N, 21);
+	bn_to_mon(m, ec_N, 21);
+	bn_to_mon(e, ec_N, 21);
+	bn_to_mon(R, ec_N, 21);
+	bn_to_mon(kk, ec_N, 21);
+
+	bn_mon_mul(S, R, kk, ec_N, 21);
+	bn_add(kk, S, e, ec_N, 21);
+	bn_mon_inv(minv, m, ec_N, 21);
+	bn_mon_mul(S, minv, kk, ec_N, 21);
+
+	bn_from_mon(R, ec_N, 21);
+	bn_from_mon(S, ec_N, 21);
+}
+
+static int check_ecdsa(struct point *Q, u8 *R, u8 *S, u8 *hash)
+{
+	u8 Sinv[21];
+	u8 e[21];
+	u8 w1[21], w2[21];
+	struct point r1, r2;
+	u8 rr[21];
+
+	e[0] = 0;
+	memcpy(e + 1, hash, 20);
+	bn_reduce(e, ec_N, 21);
+
+	bn_to_mon(R, ec_N, 21);
+	bn_to_mon(S, ec_N, 21);
+	bn_to_mon(e, ec_N, 21);
+
+	bn_mon_inv(Sinv, S, ec_N, 21);
+
+	bn_mon_mul(w1, e, Sinv, ec_N, 21);
+	bn_mon_mul(w2, R, Sinv, ec_N, 21);
+
+	bn_from_mon(w1, ec_N, 21);
+	bn_from_mon(w2, ec_N, 21);
+
+	point_mul(&r1, w1, &ec_G);
+	point_mul(&r2, w2, Q);
+
+	point_add(&r1, &r1, &r2);
+
+	point_from_mon(&r1);
+
+	rr[0] = 0;
+	memcpy(rr + 1, r1.x, 20);
+	bn_reduce(rr, ec_N, 21);
+
+	bn_from_mon(R, ec_N, 21);
+	bn_from_mon(S, ec_N, 21);
+
+	return (bn_compare(rr, R, 21) == 0);
+}
+
+#if 0
+static void ec_priv_to_pub(u8 *k, u8 *Q)
+{
+	point_mul(Q, k, ec_G);
+}
+#endif
+
+int ecdsa_set_curve(u8* p, u8* a, u8* b, u8* N, u8* Gx, u8* Gy)
+{
+	memcpy(ec_p, p, 20);
+	memcpy(ec_a, a, 20);
+	memcpy(ec_b, b, 20);
+	memcpy(ec_N, N, 21);
+	memcpy(ec_G.x, Gx, 20);
+	memcpy(ec_G.y, Gy, 20);
+	
+	bn_to_mon(ec_a, ec_p, 20);
+	bn_to_mon(ec_b, ec_p, 20);
+
+	point_to_mon(&ec_G);
+
+	return 0;
+} 
+
+void ecdsa_set_pub(u8 *Q)
+{
+	memcpy(ec_Q.x, Q, 20);
+	memcpy(ec_Q.y, Q+20, 20);
+	point_to_mon(&ec_Q);
+}
+
+void ecdsa_set_priv(u8 *k)
+{
+	memcpy(ec_k, k, sizeof ec_k);
+}
+
+int ecdsa_verify(u8 *hash, u8 *R, u8 *S)
+{
+	return check_ecdsa(&ec_Q, R, S, hash);
+}
+
+void ecdsa_sign(u8 *hash, u8 *R, u8 *S)
+{
+	generate_ecdsa(R, S, ec_k, hash);
+}

rpcs3/Crypto/ec.h

@@ -0,0 +1,14 @@
+#pragma once
+
+// Copyright (C) 2014       Hykem <hykem@hotmail.com>
+// Licensed under the terms of the GNU GPL, version 3
+// http://www.gnu.org/licenses/gpl-3.0.txt
+
+#include <string.h>
+#include <stdio.h>
+
+int ecdsa_set_curve(unsigned char *p, unsigned char *a, unsigned char *b, unsigned char *N, unsigned char *Gx, unsigned char *Gy);
+void ecdsa_set_pub(unsigned char *Q);
+void ecdsa_set_priv(unsigned char *k);
+int ecdsa_verify(unsigned char *hash, unsigned char *R, unsigned char *S);
+void ecdsa_sign(unsigned char *hash, unsigned char *R, unsigned char *S);

rpcs3/Crypto/key_vault.cpp

@@ -0,0 +1,811 @@
+#include "stdafx.h"
+#include "utils.h"
+#include "aes.h"
+#include "key_vault.h"
+
+SELF_KEY::SELF_KEY(u64 ver, u16 rev, u32 type, const std::string& e, const std::string& r, const std::string& pb, const std::string& pr, u32 ct)
+{
+	version = ver;
+	revision = rev;
+	self_type = type;
+	hex_to_bytes(erk, e.c_str(), 0);
+	hex_to_bytes(riv, r.c_str(), 0);
+	hex_to_bytes(pub, pb.c_str(), 0);
+	hex_to_bytes(priv, pr.c_str(), 0);
+	curve_type = ct;
+}
+
+KeyVault::KeyVault()
+{
+}
+
+void KeyVault::LoadSelfLV0Keys()
+{
+	sk_LV0_arr.clear();
+	sk_LV0_arr.emplace_back(0x0000000000000000, 0x0000, KEY_LV0,
+		"CA7A24EC38BDB45B98CCD7D363EA2AF0C326E65081E0630CB9AB2D215865878A",
+		"F9205F46F6021697E670F13DFA726212",
+		"A8FD6DB24532D094EFA08CB41C9A72287D905C6B27B42BE4AB925AAF4AFFF34D41EEB54DD128700D",
+		"001AD976FCDE86F5B8FF3E63EF3A7F94E861975BA3",
+		0x33);
+}
+
+void KeyVault::LoadSelfLDRKeys()
+{
+	sk_LDR_arr.clear();
+	sk_LDR_arr.emplace_back(0x0000000000000000, 0x0000, KEY_LDR,
+		"C0CEFE84C227F75BD07A7EB846509F93B238E770DACB9FF4A388F812482BE21B",
+		"47EE7454E4774CC9B8960C7B59F4C14D",
+		"C2D4AAF319355019AF99D44E2B58CA29252C89123D11D6218F40B138CAB29B7101F3AEB72A975019",
+		"00C5B2BFA1A413DD16F26D31C0F2ED4720DCFB0670",
+		0x20);
+}
+
+void KeyVault::LoadSelfLV1Keys()
+{
+	sk_LV1_arr.clear();
+	sk_LV1_arr.emplace_back(0x0003003000000000, 0x0000, KEY_LV1,
+		"B9F3F9E6107CFF2680A91E118C2403CF4A6F18F3C7EFD7D13D1AC4DB760BD222",
+		"B43661B9A79BAD9D8E2B046469CDA1E7",
+		"4C870BE86DDD996A92A3F7F404F33604244A1D02AB5B78BC9DAF030B78BE8867CF586171B7D45D20",
+		"002CC736C7AD06D264E9AB663EB1F35F5DC159248C",
+		0x33);
+	sk_LV1_arr.emplace_back(0x0003004200000000, 0x0000, KEY_LV1,
+		"B880593856C8C6D2037585626A12977F50DCFCF3F132D2C89AA6E670EAFC1646",
+		"A79B05D4E37B8117A95E6E7C14FB640E",
+		"7454C7CCBFC2F66C142D78A730A3A6F973CC0FB75A46FCBB390790138910A0CAC78E5E21F4DA3375",
+		"00033A699FDD2DA6CDD6CCC03B2C6145F998706F74",
+		0x34);
+	sk_LV1_arr.emplace_back(0x0003005000000000, 0x0000, KEY_LV1,
+		"1E8EEEA9E80A729F3FA52CF523B25941EA44B4155D94E5DADC5C5A77847620C7",
+		"E034D31A80316960024D1B3D3164FDC3",
+		"7E3A196f4A5879F3A7B091A2263F7C24E1716129B580566D308D9C2254B36AEE53DEF30EC85F8398",
+		"005815D17125D04C33790321DE29EB6241365100B5",
+		0x35);
+	sk_LV1_arr.emplace_back(0x0003005500000000, 0x0000, KEY_LV1,
+		"53ABDF84BE08B0351B734F2B97D2BE1621BC6C889E4362E5C70F39D6C3ED9F23",
+		"44E652661AC7584DBE08ECB810FB5FC0",
+		"733198A7759BC07326755BC9773A8A17C8A7043C7BDAB83D88E230512E2EA3852D7DA4263A7E97F9",
+		"004312C65347ACBE95CC306442FEFD0AF4C2935EB3",
+		0x05);
+	sk_LV1_arr.emplace_back(0x0003005600000000, 0x0000, KEY_LV1,
+		"48793EBDDA1AF65D737DA2FDA2DD104447A698F8A82CAAEE992831711BA94E83",
+		"15DCF3C67147A45D09DE7521EECA07A1",
+		"85A8868C320127F10B6598964C69221C086702021D31803520E21FDE4DBE827766BE41825CB7328C",
+		"",
+		0x07);
+	sk_LV1_arr.emplace_back(0x0003006100000000, 0x0000, KEY_LV1,
+		"5FF17D836E2C4AD69476E2614F64BDD05B9115389A9A6D055B5B544B1C34E3D5",
+		"DF0F50EC3C4743C5B17839D7B49F24A4",
+		"1CDABE30833823F461CA534104115FFF60010B710631E435A7D915E82AE88EDE667264656CB7062E",
+		"",
+		0x05);
+	sk_LV1_arr.emplace_back(0x0003006600000000, 0x0000, KEY_LV1,
+		"BD0621FA19383C3C72ECBC3B008F1CD55FFD7C3BB7510BF11AD0CF0FC2B70951",
+		"569AF3745E1E02E3E288273CDE244CD8",
+		"21E26F11C2D69478609DD1BD278CDFC940D90386455BA52FCD1FA7E27AC2AFA826C79A10193B625C",
+		"",
+		0x07);
+	sk_LV1_arr.emplace_back(0x0003007400000000, 0x0000, KEY_LV1,
+		"41A6E0039041E9D8AAF4EF2F2A2971248EDBD96A3985611ED7B4CE73EE4804FE",
+		"C8C98D5A5CE23AF5607A352AECACB0DC",
+		"4389664390265F96C1A882374C0F856364E33DB09BE124A4666F9A12F0DD9C811EDD55BA21ED0667",
+		"",
+		0x12);
+	sk_LV1_arr.emplace_back(0x0004001100000000, 0x0000, KEY_LV1,
+		"557EDF6C063F3272B0D44EEC12F418DA774815B5415597CC5F75C21E048BAD74",
+		"7144D7574937818517826227EF4AC0B4",
+		"085D38DBF9B757329EB862107929909D32FA1DAE60641BF4AC25319D7650597EE977F8E810FEEA96",
+		"",
+		0x13);
+	sk_LV1_arr.emplace_back(0x0004005000000000, 0x0000, KEY_LV1,
+		"10CEA04973FCCC12EC19924510822D8D4C41F657FD3D7E73F415A8D687421BCD",
+		"ED8699562C6AC65204FA166257E7FCF4",
+		"9AF86FC869C159FBB62F7D9674EE257ABF12E5A96D5875B4AA73C13C2BC13E2A4079F98B9B935EE2",
+		"",
+		0x14);
+}
+
+void KeyVault::LoadSelfLV2Keys()
+{
+	sk_LV2_arr.clear();
+	sk_LV2_arr.emplace_back(0x0003003000000000, 0x0000, KEY_LV2,
+		"94303F69513572AB5AE17C8C2A1839D2C24C28F65389D3BBB11894CE23E0798F",
+		"9769BFD187B90990AE5FEA4E110B9CF5",
+		"AFAF5E96AF396CBB69071082C46A8F34A030E8EDB799E0A7BE00AA264DFF3AEBF7923920D559404D",
+		"0070ABF9361B02291829D479F56AB248203CD3EB46",
+		0x20);
+	sk_LV2_arr.emplace_back(0x0003004200000000, 0x0000, KEY_LV2,
+		"575B0A6C4B4F2760A03FE4189EBAF4D947279FD982B14070349098B08FF92C10",
+		"411CB18F460CE50CAF2C426D8F0D93C8",
+		"3FEE313954CB3039C321A7E33B97FFDEC8988A8B55759161B04DBF4731284E4A8191E3F17D32B0EA",
+		"0073076441A08CD179E5FACE349B86DA58B5B7BA78",
+		0x21);
+	sk_LV2_arr.emplace_back(0x0003005000000000, 0x0000, KEY_LV2,
+		"6DBD48D787C58803A8D724DA5ACF04FF8FCE91D7545D2322F2B7ABF57014AF68",
+		"603A36213708520ED5D745DEC1325BA5",
+		"5888CB83AC3CCA9610BC173C53141C0CA58B93719E744660CA8823D5EAEE8F9BF736997054E4B7E3",
+		"0009EBC3DE442FA5FBF6C4F3D4F9EAB07778A142BD",
+		0x22);
+	sk_LV2_arr.emplace_back(0x0003005500000000, 0x0000, KEY_LV2,
+		"84015E90FA23139628A3C75CC09714E6427B527A82D18ABC3E91CD8D7DDAFF17",
+		"5B240444D645F2038118F97FD5A145D5",
+		"B266318245266B2D33641CD8A864066D077FAC60B7E27399099A70A683454B70F9888E7CC0C2BF72",
+		"009D4CBA2BFB1A8330D3E20E59D281D476D231C73A",
+		0x32);
+	sk_LV2_arr.emplace_back(0x0003005600000000, 0x0000, KEY_LV2,
+		"EAE15444048EFDE7A831BFA9F5D96F047C9FCFF50723E292CF50F5417D81E359",
+		"9CA9282DC7FA9F315EF3156D970B7CD4",
+		"0D58938CB47598A6A672874F1768068F8B80D8D17014D2ABEBAC85E5B0993D9FB6F307DDC3DDA699",
+		"",
+		0x33);
+	sk_LV2_arr.emplace_back(0x0003006100000000, 0x0000, KEY_LV2,
+		"88AD367EDEC2FEED3E2F99B1C685075C41BDEC90C84F526CAF588F89BBD1CBCC",
+		"8D18E8E525230E63DE10291C9DD615BF",
+		"86EED1D65E58890ABDA9ACA486A2BDDB9C0A529C2053FAE301F0F698EAF443DA0F60595A597A7027",
+		"",
+		0x32);
+	sk_LV2_arr.emplace_back(0x0003006600000000, 0x0000, KEY_LV2,
+		"688D5FCAC6F4EA35AC6AC79B10506007286131EE038116DB8AA2C0B0340D9FB0",
+		"75E0239D18B0B669EAE650972F99726B",
+		"008E1C820AC567D1BFB8FE3CC6AD2E1845A1D1B19ED2E18B18CA34A8D28A83EC60C63859CDB3DACA",
+		"",
+		0x33);
+	sk_LV2_arr.emplace_back(0x0003007400000000, 0x0000, KEY_LV2,
+		"E81C5B04C29FB079A4A2687A39D4EA97BFB49D80EF546CEB292979A5F77A6254",
+		"15058FA7F2CAD7C528B5F605F6444EB0",
+		"438D0E5C1E7AFB18234DB6867472FF5F52B750F30C379C7DD1EE0FD23E417B3EA819CC01BAC480ED",
+		"",
+		0x11);
+	sk_LV2_arr.emplace_back(0x0004001100000000, 0x0000, KEY_LV2,
+		"A1E4B86ED02BF7F1372A2C73FE02BC738907EB37CE3BA605FE783C999FAFDB97",
+		"BBE7799B9A37CB272E386618FDFD4AEC",
+		"5B31A8E2A663EBD673196E2E1022E0D64988C4E1BBFE5E474415883A3BA0D9C562A2BE9C30E9B4A8",
+		"",
+		0x07);
+	sk_LV2_arr.emplace_back(0x0004005000000000, 0x0000, KEY_LV2,
+		"0CAF212B6FA53C0DA7E2C575ADF61DBE68F34A33433B1B891ABF5C4251406A03",
+		"9B79374722AD888EB6A35A2DF25A8B3E",
+		"1034A6F98AF6625CC3E3604B59B971CA617DF337538D2179EBB22F3BDC9D0C6DA56BA7DDFD205A50",
+		"",
+		0x14);
+}
+
+void KeyVault::LoadSelfISOKeys()
+{
+	sk_ISO_arr.clear();
+	sk_ISO_arr.emplace_back(0x0003003000000000, 0x0001, KEY_ISO,
+		"8860D0CFF4D0DC688D3223321B96B59A777E6914961488E07048DAECB020ECA4",
+		"C82D015D46CF152F1DD0C16F18B5B1E5",
+		"733918D7C888130509346E6B4A8B6CAA357AB557E814E8122BF102C14A314BF9475B9D70EAF9EC29",
+		"009BE892E122A5C943C1BB7403A67318AA9E1B286F",
+		0x36);
+	sk_ISO_arr.emplace_back(0x0003004200000000, 0x0001, KEY_ISO,
+		"101E27F3FA2FB53ACA924F783AD553162D56B975D05B81351A1111799F20254D",
+		"8D2E9C6297B8AD252998458296AC773C",
+		"138446EE0BDDA5638F97328C8956E6489CBBFE57C5961D40DD5C43BB4138F1C400A8B27204A5D625",
+		"00849DBC57D3B92F01864E6E82EB4EF0EF6311E122",
+		0x32);
+	sk_ISO_arr.emplace_back(0x0003005000000000, 0x0001, KEY_ISO,
+		"3F2604FA27AEADFBE1AC69EB00BB16EF196C2193CBD62900FFD8C25041680843",
+		"A414AC1DB7987E43777651B330B899E1",
+		"1F4633AFDE18614D6CEF38A2FD6C4CCAC7B6EB8109D72CD066ECEBA0193EA3F43C37AE83179A4E5F",
+		"0085B4B05DEBA7E6AD831653C974D95149803BB272",
+		0x33);
+	sk_ISO_arr.emplace_back(0x0003005500000000, 0x0001, KEY_ISO,
+		"BDB74AA6E3BA2DC10B1BD7F17198399A158DBE1FA0BEA68C90FCACBE4D04BE37",
+		"0207A479B1574F8E7F697528F05D5435",
+		"917E1F1DC48A54EB5F10B38E7569BB5383628A7C906F0DCA62FDA33805C15FAB270016940A09DB58",
+		"00294411363290975BA551336D3965D88AF029A17B",
+		0x03);
+	sk_ISO_arr.emplace_back(0x0003005600000000, 0x0001, KEY_ISO,
+		"311C015F169F2A1E0757F7064B14C7C9F3A3FFEE015BD4E3A22401A2667857CE",
+		"7BB8B3F5AC8E0890E3148AE5688C7350",
+		"3F040EFA2335FED5670BA4D5C3AB2D9D0B4BA69D154A0062EA995A7D21DBAF0DC5A0DAD333D1C1DD",
+		"",
+		0x08);
+	sk_ISO_arr.emplace_back(0x0003006100000000, 0x0001, KEY_ISO,
+		"8474ADCA3B3244931EECEB9357841442442A1C4A4BCF4E498E6738950F4E4093",
+		"FFF9CACCC4129125CAFB240F419E5F39",
+		"098E1A53E59A95316B00D5A29C05FFEBAE41D1A8A386F9DA96F98858FD25E07BB7A3BC96A5D5B556",
+		"",
+		0x03);
+	sk_ISO_arr.emplace_back(0x0003006600000000, 0x0001, KEY_ISO,
+		"E6A21C599B75696C169EC02582BDA74A776134A6E05108EA701EC0CA2AC03592",
+		"D292A7BD57C0BB2EABBCA1252FA9EDEF",
+		"2ED078A13DC4617EB550AD06E228C83C142A2D588EB5E729402D18038A14842FD65B277DCAD225A5",
+		"",
+		0x08);
+	sk_ISO_arr.emplace_back(0x0003007400000000, 0x0001, KEY_ISO,
+		"072D3A5C3BDB0D674DE209381432B20414BC9BDA0F583ECB94BD9A134176DD51",
+		"8516A81F02CF938740498A406C880871",
+		"5A778DEB5C4F12E8D48E06A2BBBBE3C90FA8C6C47DF9BDB5697FD4A8EB7941CE3F59A557E81C787D",
+		"",
+		0x21);
+	sk_ISO_arr.emplace_back(0x0003007400000000, 0x0100, KEY_ISO,
+		"786FAB8A0B89474A2CB80B3EA104CCCB9E13F66B45EC499BB31865D07C661EA8",
+		"94662F13D99A9F5D211C979FFDF65FE3",
+		"912C94C252B7799CEB45DFBB73EF7CAD9BCC0793A3331BBB79E3C47C0F5C782F698065A8D4DB0D8B",
+		"",
+		0x0E);
+	sk_ISO_arr.emplace_back(0x0004001100000000, 0x0001, KEY_ISO,
+		"4262657A3185D9480F82C8BD2F81766FCC2C8FD7DD5EBE8657B00B939E0C75BD",
+		"4F1E3EF07D893A4714B1B3D5A4E50479",
+		"4DBFCFA68B52F1D66E09AFA6C18EC65479EDBD027B6B8C6A5D85FE5C84D43EA40CEF1672078A0702",
+		"",
+		0x11);
+	sk_ISO_arr.emplace_back(0x0004001100000000, 0x0100, KEY_ISO,
+		"16AA7D7C35399E2B1BFAF68CD19D7512A7855029C08BECC4CC3F035DF7F9C70B",
+		"0E50DB6D937D262CB0499136852FCB80",
+		"AEE2795BF295662A50DFAFE70D1B0B6F0A2EBB211E1323A275FC6E2D13BE4F2F10CA34784F4CF1EC",
+		"",
+		0x0F);
+	sk_ISO_arr.emplace_back(0x0004005000000000, 0x0001, KEY_ISO,
+		"63565DBE98C3B1A52AADC907C47130FE57A10734E84F22592670F86ED2B0A086",
+		"953F6A99891B4739358F5363A00C08B9",
+		"26BE7B02E7D65C6C21BF4063CDB8C0092FE1679D62FA1A8CCC284A1D21885473A959992537A06612",
+		"",
+		0x15);
+	sk_ISO_arr.emplace_back(0x0004005000000000, 0x0100, KEY_ISO,
+		"B96EA32CB96EA32DB96EA32CB96EA32CB96EA32CB96EA32DB96EA32CB96EA32C",
+		"B96EA32CB96EA32DB96EA32DB96EA32C",
+		"2D7066E68C6AC3373B1346FD76FE7D18A207C811500E65D85DB57BC4A27AD78F59FD53F38F50E151",
+		"0044AA25B4276D79B494A29CB8DE104642424F8EEF",
+		0x02);
+}
+
+void KeyVault::LoadSelfAPPKeys()
+{
+	sk_APP_arr.clear();
+	sk_APP_arr.emplace_back(0x0000009200000000, 0x0000, KEY_APP,
+		"95F50019E7A68E341FA72EFDF4D60ED376E25CF46BB48DFDD1F080259DC93F04",
+		"4A0955D946DB70D691A640BB7FAECC4C",
+		"6F8DF8EBD0A1D1DB08B30DD3A951E3F1F27E34030B42C729C55555232D61B834B8BDFFB07E54B343",
+		"006C3E4CCB2C69A5AD7C6F60448E50C7F9184EEAF4",
+		0x21);
+	sk_APP_arr.emplace_back(0x0003003000000000, 0x0001, KEY_APP,
+		"79481839C406A632BDB4AC093D73D99AE1587F24CE7E69192C1CD0010274A8AB",
+		"6F0F25E1C8C4B7AE70DF968B04521DDA",
+		"94D1B7378BAFF5DFED269240A7A364ED68446741622E50BC6079B6E606A2F8E0A4C56E5CFF836526",
+		"003DE80167D2F0E9D30F2145144A558D1174F5410C",
+		0x11);
+	sk_APP_arr.emplace_back(0x0003003000000000, 0x0002, KEY_APP,
+		"4F89BE98DDD43CAD343F5BA6B1A133B0A971566F770484AAC20B5DD1DC9FA06A",
+		"90C127A9B43BA9D8E89FE6529E25206F",
+		"8CA6905F46148D7D8D84D2AFCEAE61B41E6750FC22EA435DFA61FCE6F4F860EE4F54D9196CA5290E",
+		"",
+		0x13);
+	sk_APP_arr.emplace_back(0x0003003000000000, 0x0003, KEY_APP,
+		"C1E6A351FCED6A0636BFCB6801A0942DB7C28BDFC5E0A053A3F52F52FCE9754E",
+		"E0908163F457576440466ACAA443AE7C",
+		"50022D5D37C97905F898E78E7AA14A0B5CAAD5CE8190AE5629A10D6F0CF4173597B37A95A7545C92",
+		"",
+		0x0B);
+	sk_APP_arr.emplace_back(0x0003004200000000, 0x0004, KEY_APP,
+		"838F5860CF97CDAD75B399CA44F4C214CDF951AC795298D71DF3C3B7E93AAEDA",
+		"7FDBB2E924D182BB0D69844ADC4ECA5B",
+		"1F140E8EF887DAB52F079A06E6915A6460B75CD256834A43FA7AF90C23067AF412EDAFE2C1778D69",
+		"0074E922FDEE5DC4CDF22FC8D7986477F813400860",
+		0x14);
+	sk_APP_arr.emplace_back(0x0003004200000000, 0x0005, KEY_APP,
+		"C109AB56593DE5BE8BA190578E7D8109346E86A11088B42C727E2B793FD64BDC",
+		"15D3F191295C94B09B71EBDE088A187A",
+		"B6BB0A84C649A90D97EBA55B555366F52381BB38A84C8BB71DA5A5A0949043C6DB249029A43156F7",
+		"",
+		0x15);
+	sk_APP_arr.emplace_back(0x0003004200000000, 0x0006, KEY_APP,
+		"6DFD7AFB470D2B2C955AB22264B1FF3C67F180983B26C01615DE9F2ECCBE7F41",
+		"24BD1C19D2A8286B8ACE39E4A37801C2",
+		"71F46AC33FF89DF589A100A7FB64CEAC244C9A0CBBC1FDCE80FB4BF8A0D2E66293309CB8EE8CFA95",
+		"",
+		0x2C);
+	sk_APP_arr.emplace_back(0x0003005000000000, 0x0007, KEY_APP,
+		"945B99C0E69CAF0558C588B95FF41B232660ECB017741F3218C12F9DFDEEDE55",
+		"1D5EFBE7C5D34AD60F9FBC46A5977FCE",
+		"AB284CA549B2DE9AA5C903B75652F78D192F8F4A8F3CD99209415C0A84C5C9FD6BF3095C1C18FFCD",
+		"002CF896D35DB871D0E6A252E799876A70D043C23E",
+		0x15);
+	sk_APP_arr.emplace_back(0x0003005000000000, 0x0008, KEY_APP,
+		"2C9E8969EC44DFB6A8771DC7F7FDFBCCAF329EC3EC070900CABB23742A9A6E13",
+		"5A4CEFD5A9C3C093D0B9352376D19405",
+		"6E82F6B54A0E9DEBE4A8B3043EE3B24CD9BBB62B4416B0482582E419A2552E29AB4BEA0A4D7FA2D5",
+		"",
+		0x16);
+	sk_APP_arr.emplace_back(0x0003005000000000, 0x0009, KEY_APP,
+		"F69E4A2934F114D89F386CE766388366CDD210F1D8913E3B973257F1201D632B",
+		"F4D535069301EE888CC2A852DB654461",
+		"1D7B974D10E61C2ED087A0981535904677EC07E96260F89565FF7EBDA4EE035C2AA9BCBDD5893F99",
+		"",
+		0x2D);
+	sk_APP_arr.emplace_back(0x0003005500000000, 0x000A, KEY_APP,
+		"29805302E7C92F204009161CA93F776A072141A8C46A108E571C46D473A176A3",
+		"5D1FAB844107676ABCDFC25EAEBCB633",
+		"09301B6436C85B53CB1585300A3F1AF9FB14DB7C30088C4642AD66D5C148B8995BB1A698A8C71827",
+		"0010818ED8A666051C6198662C3D6DDE2CA4901DDC",
+		0x25);
+	sk_APP_arr.emplace_back(0x0003005500000000, 0x000B, KEY_APP,
+		"A4C97402CC8A71BC7748661FE9CE7DF44DCE95D0D58938A59F47B9E9DBA7BFC3",
+		"E4792F2B9DB30CB8D1596077A13FB3B5",
+		"2733C889D289550FE00EAA5A47A34CEF0C1AF187610EB07BA35D2C09BB73C80B244EB4147700D1BF",
+		"",
+		0x26);
+	sk_APP_arr.emplace_back(0x0003005500000000, 0x000C, KEY_APP,
+		"9814EFFF67B7074D1B263BF85BDC8576CE9DEC914123971B169472A1BC2387FA",
+		"D43B1FA8BE15714B3078C23908BB2BCA",
+		"7D1986C6BEE6CE1E0C5893BD2DF203881F40D5056761CC3F1F2E9D9A378617A2DE40BA5F09844CEB",
+		"",
+		0x3D);
+	sk_APP_arr.emplace_back(0x0003005600000000, 0x000D, KEY_APP,
+		"03B4C421E0C0DE708C0F0B71C24E3EE04306AE7383D8C5621394CCB99FF7A194",
+		"5ADB9EAFE897B54CB1060D6885BE22CF",
+		"71502ADB5783583AB88B2D5F23F419AF01C8B1E72FCA1E694AD49FE3266F1F9C61EFC6F29B351142",
+		"",
+		0x12);
+	sk_APP_arr.emplace_back(0x0003005600000000, 0x000E, KEY_APP,
+		"39A870173C226EB8A3EEE9CA6FB675E82039B2D0CCB22653BFCE4DB013BAEA03",
+		"90266C98CBAA06C1BF145FF760EA1B45",
+		"84DE5692809848E5ACBE25BE548F6981E3DB14735A5DDE1A0FD1F475866532B862B1AB6A004B7255",
+		"",
+		0x27);
+	sk_APP_arr.emplace_back(0x0003005600000000, 0x000F, KEY_APP,
+		"FD52DFA7C6EEF5679628D12E267AA863B9365E6DB95470949CFD235B3FCA0F3B",
+		"64F50296CF8CF49CD7C643572887DA0B",
+		"0696D6CCBD7CF585EF5E00D547503C185D7421581BAD196E081723CD0A97FA40B2C0CD2492B0B5A1",
+		"",
+		0x3A);
+	sk_APP_arr.emplace_back(0x0003006100000000, 0x0010, KEY_APP,
+		"A5E51AD8F32FFBDE808972ACEE46397F2D3FE6BC823C8218EF875EE3A9B0584F",
+		"7A203D5112F799979DF0E1B8B5B52AA4",
+		"50597B7F680DD89F6594D9BDC0CBEE03666AB53647D0487F7F452FE2DD02694631EA755548C9E934",
+		"",
+		0x25);
+	sk_APP_arr.emplace_back(0x0003006100000000, 0x0011, KEY_APP,
+		"0F8EAB8884A51D092D7250597388E3B8B75444AC138B9D36E5C7C5B8C3DF18FD",
+		"97AF39C383E7EF1C98FA447C597EA8FE",
+		"2FDA7A56AAEA65921C0284FF1942C6DE137370093D106034B59191951A5201B422D462F8726F852D",
+		"",
+		0x26);
+	sk_APP_arr.emplace_back(0x0003006600000000, 0x0013, KEY_APP,
+		"DBF62D76FC81C8AC92372A9D631DDC9219F152C59C4B20BFF8F96B64AB065E94",
+		"CB5DD4BE8CF115FFB25801BC6086E729",
+		"B26FE6D3E3A1E766FAE79A8E6A7F48998E7FC1E4B0AD8745FF54C018C2A6CC7A0DD7525FAFEA4917",
+		"",
+		0x12);
+	sk_APP_arr.emplace_back(0x0003006600000000, 0x0014, KEY_APP,
+		"491B0D72BB21ED115950379F4564CE784A4BFAABB00E8CB71294B192B7B9F88E",
+		"F98843588FED8B0E62D7DDCB6F0CECF4",
+		"04275E8838EF95BD013B223C3DF674540932F21B534C7ED2944B9104D938FEB03B824DDB866AB26E",
+		"",
+		0x27);
+	sk_APP_arr.emplace_back(0x0003007400000000, 0x0016, KEY_APP,
+		"A106692224F1E91E1C4EBAD4A25FBFF66B4B13E88D878E8CD072F23CD1C5BF7C",
+		"62773C70BD749269C0AFD1F12E73909E",
+		"566635D3E1DCEC47243AAD1628AE6B2CEB33463FC155E4635846CE33899C5E353DDFA47FEF5694AF",
+		"",
+		0x30);
+	sk_APP_arr.emplace_back(0x0003007400000000, 0x0017, KEY_APP,
+		"4E104DCE09BA878C75DA98D0B1636F0E5F058328D81419E2A3D22AB0256FDF46",
+		"954A86C4629E116532304A740862EF85",
+		"3B7B04C71CAE2B1199D57453C038BB1B541A05AD1B94167B0AB47A9B24CAECB9000CB21407009666",
+		"",
+		0x08);
+	sk_APP_arr.emplace_back(0x0003007400000000, 0x0018, KEY_APP,
+		"1F876AB252DDBCB70E74DC4A20CD8ED51E330E62490E652F862877E8D8D0F997",
+		"BF8D6B1887FA88E6D85C2EDB2FBEC147",
+		"64A04126D77BF6B4D686F6E8F87DD150A5B014BA922D2B694FFF4453E11239A6E0B58F1703C51494",
+		"",
+		0x11);
+	sk_APP_arr.emplace_back(0x0004001100000000, 0x0019, KEY_APP,
+		"3236B9937174DF1DC12EC2DD8A318A0EA4D3ECDEA5DFB4AC1B8278447000C297",
+		"6153DEE781B8ADDC6A439498B816DC46",
+		"148DCA961E2738BAF84B2D1B6E2DA2ABD6A95F2C9571E54C6922F9ED9674F062B7F1BE5BD6FA5268",
+		"",
+		0x31);
+	sk_APP_arr.emplace_back(0x0004001100000000, 0x001A, KEY_APP,
+		"5EFD1E9961462794E3B9EF2A4D0C1F46F642AAE053B5025504130590E66F19C9",
+		"1AC8FA3B3C90F8FDE639515F91B58327",
+		"BE4B1B513536960618BFEF12A713F6673881B02F9DC616191E823FC8337CCF99ADAA6172019C0C23",
+		"",
+		0x17);
+	sk_APP_arr.emplace_back(0x0004001100000000, 0x001B, KEY_APP,
+		"66637570D1DEC098467DB207BAEA786861964D0964D4DBAF89E76F46955D181B",
+		"9F7B5713A5ED59F6B35CD8F8A165D4B8",
+		"4AB6FB1F6F0C3D9219923C1AC683137AB05DF667833CC6A5E8F590E4E28FE2EB180C7D5861117CFB",
+		"",
+		0x12);
+	sk_APP_arr.emplace_back(0x0004004600000000, 0x001C, KEY_APP,
+		"CFF025375BA0079226BE01F4A31F346D79F62CFB643CA910E16CF60BD9092752",
+		"FD40664E2EBBA01BF359B0DCDF543DA4",
+		"36C1ACE6DD5CCC0006FDF3424750FAC515FC5CFA2C93EC53C6EC2BC421708D154E91F2E7EA54A893",
+		"",
+		0x09);
+	sk_APP_arr.emplace_back(0x0004004600000000, 0x001D, KEY_APP,
+		"D202174EB65A62048F3674B59EF6FE72E1872962F3E1CD658DE8D7AF71DA1F3E",
+		"ACB9945914EBB7B9A31ECE320AE09F2D",
+		"430322887503CF52928FAAA410FD623C7321281C8825D95F5B47EF078EFCFC44454C3AB4F00BB879",
+		"",
+		0x1A);
+}
+
+void KeyVault::LoadSelfNPDRMKeys()
+{
+	sk_NPDRM_arr.clear();
+	sk_NPDRM_arr.emplace_back(0x0001000000000000, 0x0001, KEY_NPDRM,
+		"F9EDD0301F770FABBA8863D9897F0FEA6551B09431F61312654E28F43533EA6B",
+		"A551CCB4A42C37A734A2B4F9657D5540",
+		"B05F9DA5F9121EE4031467E74C505C29A8E29D1022379EDFF0500B9AE480B5DAB4578A4C61C5D6BF",
+		"00040AB47509BED04BD96521AD1B365B86BF620A98",
+		0x11);
+	sk_NPDRM_arr.emplace_back(0x0001000000000000, 0x0002, KEY_NPDRM,
+		"8E737230C80E66AD0162EDDD32F1F774EE5E4E187449F19079437A508FCF9C86",
+		"7AAECC60AD12AED90C348D8C11D2BED5",
+		"05BF09CB6FD78050C78DE69CC316FF27C9F1ED66A45BFCE0A1E5A6749B19BD546BBB4602CF373440",
+		"",
+		0x0A);
+	sk_NPDRM_arr.emplace_back(0x0003003000000000, 0x0003, KEY_NPDRM,
+		"1B715B0C3E8DC4C1A5772EBA9C5D34F7CCFE5B82025D453F3167566497239664",
+		"E31E206FBB8AEA27FAB0D9A2FFB6B62F",
+		"3F51E59FC74D6618D34431FA67987FA11ABBFACC7111811473CD9988FE91C43FC74605E7B8CB732D",
+		"",
+		0x08);
+	sk_NPDRM_arr.emplace_back(0x0003004200000000, 0x0004, KEY_NPDRM,
+		"BB4DBF66B744A33934172D9F8379A7A5EA74CB0F559BB95D0E7AECE91702B706",
+		"ADF7B207A15AC601110E61DDFC210AF6",
+		"9C327471BAFF1F877AE4FE29F4501AF5AD6A2C459F8622697F583EFCA2CA30ABB5CD45D1131CAB30",
+		"00B61A91DF4AB6A9F142C326BA9592B5265DA88856",
+		0x16);
+	sk_NPDRM_arr.emplace_back(0x0003004200000000, 0x0006, KEY_NPDRM,
+		"8B4C52849765D2B5FA3D5628AFB17644D52B9FFEE235B4C0DB72A62867EAA020",
+		"05719DF1B1D0306C03910ADDCE4AF887",
+		"2A5D6C6908CA98FC4740D834C6400E6D6AD74CF0A712CF1E7DAE806E98605CC308F6A03658F2970E",
+		"",
+		0x29);
+	sk_NPDRM_arr.emplace_back(0x0003005000000000, 0x0007, KEY_NPDRM,
+		"3946DFAA141718C7BE339A0D6C26301C76B568AEBC5CD52652F2E2E0297437C3",
+		"E4897BE553AE025CDCBF2B15D1C9234E",
+		"A13AFE8B63F897DA2D3DC3987B39389DC10BAD99DFB703838C4A0BC4E8BB44659C726CFD0CE60D0E",
+		"009EF86907782A318D4CC3617EBACE2480E73A46F6",
+		0x17);
+	sk_NPDRM_arr.emplace_back(0x0003005000000000, 0x0009, KEY_NPDRM,
+		"0786F4B0CA5937F515BDCE188F569B2EF3109A4DA0780A7AA07BD89C3350810A",
+		"04AD3C2F122A3B35E804850CAD142C6D",
+		"A1FE61035DBBEA5A94D120D03C000D3B2F084B9F4AFA99A2D4A588DF92B8F36327CE9E47889A45D0",
+		"",
+		0x2A);
+	sk_NPDRM_arr.emplace_back(0x0003005500000000, 0x000A, KEY_NPDRM,
+		"03C21AD78FBB6A3D425E9AAB1298F9FD70E29FD4E6E3A3C151205DA50C413DE4",
+		"0A99D4D4F8301A88052D714AD2FB565E",
+		"3995C390C9F7FBBAB124A1C14E70F9741A5E6BDF17A605D88239652C8EA7D5FC9F24B30546C1E44B",
+		"009AC6B22A056BA9E0B6D1520F28A57A3135483F9F",
+		0x27);
+	sk_NPDRM_arr.emplace_back(0x0003005500000000, 0x000C, KEY_NPDRM,
+		"357EBBEA265FAEC271182D571C6CD2F62CFA04D325588F213DB6B2E0ED166D92",
+		"D26E6DD2B74CD78E866E742E5571B84F",
+		"00DCF5391618604AB42C8CFF3DC304DF45341EBA4551293E9E2B68FFE2DF527FFA3BE8329E015E57",
+		"",
+		0x3A);
+	sk_NPDRM_arr.emplace_back(0x0003005600000000, 0x000D, KEY_NPDRM,
+		"337A51416105B56E40D7CAF1B954CDAF4E7645F28379904F35F27E81CA7B6957",
+		"8405C88E042280DBD794EC7E22B74002",
+		"9BFF1CC7118D2393DE50D5CF44909860683411A532767BFDAC78622DB9E5456753FE422CBAFA1DA1",
+		"",
+		0x18);
+	sk_NPDRM_arr.emplace_back(0x0003005600000000, 0x000F, KEY_NPDRM,
+		"135C098CBE6A3E037EBE9F2BB9B30218DDE8D68217346F9AD33203352FBB3291",
+		"4070C898C2EAAD1634A288AA547A35A8",
+		"BBD7CCCB556C2EF0F908DC7810FAFC37F2E56B3DAA5F7FAF53A4944AA9B841F76AB091E16B231433",
+		"",
+		0x3B);
+	sk_NPDRM_arr.emplace_back(0x0003006100000000, 0x0010, KEY_NPDRM,
+		"4B3CD10F6A6AA7D99F9B3A660C35ADE08EF01C2C336B9E46D1BB5678B4261A61",
+		"C0F2AB86E6E0457552DB50D7219371C5",
+		"64A5C60BC2AD18B8A237E4AA690647E12BF7A081523FAD4F29BE89ACAC72F7AB43C74EC9AFFDA213",
+		"",
+		0x27);
+	sk_NPDRM_arr.emplace_back(0x0003006600000000, 0x0013, KEY_NPDRM,
+		"265C93CF48562EC5D18773BEB7689B8AD10C5EB6D21421455DEBC4FB128CBF46",
+		"8DEA5FF959682A9B98B688CEA1EF4A1D",
+		"9D8DB5A880608DC69717991AFC3AD5C0215A5EE413328C2ABC8F35589E04432373DB2E2339EEF7C8",
+		"",
+		0x18);
+	sk_NPDRM_arr.emplace_back(0x0003007400000000, 0x0016, KEY_NPDRM,
+		"7910340483E419E55F0D33E4EA5410EEEC3AF47814667ECA2AA9D75602B14D4B",
+		"4AD981431B98DFD39B6388EDAD742A8E",
+		"62DFE488E410B1B6B2F559E4CB932BCB78845AB623CC59FDF65168400FD76FA82ED1DC60E091D1D1",
+		"",
+		0x25);
+	sk_NPDRM_arr.emplace_back(0x0004001100000000, 0x0019, KEY_NPDRM,
+		"FBDA75963FE690CFF35B7AA7B408CF631744EDEF5F7931A04D58FD6A921FFDB3",
+		"F72C1D80FFDA2E3BF085F4133E6D2805",
+		"637EAD34E7B85C723C627E68ABDD0419914EBED4008311731DD87FDDA2DAF71F856A70E14DA17B42",
+		"",
+		0x24);
+	sk_NPDRM_arr.emplace_back(0x0004004600000000, 0x001C, KEY_NPDRM,
+		"8103EA9DB790578219C4CEDF0592B43064A7D98B601B6C7BC45108C4047AA80F",
+		"246F4B8328BE6A2D394EDE20479247C5",
+		"503172C9551308A87621ECEE90362D14889BFED2CF32B0B3E32A4F9FE527A41464B735E1ADBC6762",
+		"",
+		0x30);
+}
+
+void KeyVault::LoadSelfUNK7Keys()
+{
+	sk_UNK7_arr.clear();
+	sk_UNK7_arr.emplace_back(0x0003003000000000, 0x0000, KEY_UNK7,
+		"D91166973979EA8694476B011AC62C7E9F37DA26DE1E5C2EE3D66E42B8517085",
+		"DC01280A6E46BC674B81A7E8801EBE6E",
+		"A0FC44108236141BF3517A662B027AFC1AC513A05690496C754DEB7D43BDC41B80FD75C212624EE4",
+		"",
+		0x11);
+	sk_UNK7_arr.emplace_back(0x0003004200000000, 0x0000, KEY_UNK7,
+		"B73111B0B00117E48DE5E2EE5E534C0F0EFFA4890BBB8CAD01EE0F848F91583E",
+		"86F56F9E5DE513894874B8BA253334B1",
+		"B0BA1A1AB9723BB4E87CED9637BE056066BC56E16572D43D0210A06411DBF8FEB8885CD912384AE5",
+		"",
+		0x12);
+	sk_UNK7_arr.emplace_back(0x0003005000000000, 0x0000, KEY_UNK7,
+		"8E944267C02E69A4FE474B7F5FCD7974A4F936FF4355AEC4F80EFA123858D8F6",
+		"908A75754E521EAC2F5A4889C6D7B72D",
+		"91201DA7D79E8EE2563142ECBD646DA026C963AC09E760E5390FFE24DAE6864310ABE147F8204D0B",
+		"",
+		0x13);
+	sk_UNK7_arr.emplace_back(0x0003005500000000, 0x0000, KEY_UNK7,
+		"BB31DF9A6F62C0DF853075FAA65134D9CE2240306C1731D1F7DA9B5329BD699F",
+		"263057225873F83940A65C8C926AC3E4",
+		"BC3A82A4F44C43A197070CD236FDC94FCC542D69A3E803E0AFF78D1F3DA19A79D2F61FAB5B94B437",
+		"",
+		0x23);
+	sk_UNK7_arr.emplace_back(0x0003005600000000, 0x0000, KEY_UNK7,
+		"71AA75C70A255580E4AE9BDAA0B08828C53EAA713CD0713797F143B284C1589B",
+		"9DED878CB6BA07121C0F50E7B172A8BF",
+		"387FCDAEAFF1B59CFAF79CE6215A065ACEAFFAF4048A4F217E1FF5CE67C66EC3F089DB235E52F9D3",
+		"",
+		0x29);
+	sk_UNK7_arr.emplace_back(0x0003006100000000, 0x0000, KEY_UNK7,
+		"F5D1DBC182F5083CD4EA37C431C7DAC73882C07F232D2699B1DD9FDDF1BF4195",
+		"D3A7C3C91CBA014FCBCA6D5570DE13FF",
+		"97CA8A9781F45E557E98F176EF794FCDA6B151EB3DFD1ABA12151E00AE59957C3B15628FC8875D28",
+		"",
+		0x23);
+	sk_UNK7_arr.emplace_back(0x0003006600000000, 0x0000, KEY_UNK7,
+		"BF10F09590C0152F7EF749FF4B990122A4E8E5491DA49A2D931E72EEB990F860",
+		"22C19C5522F7A782AFC547C2640F5BDE",
+		"3233BA2B284189FB1687DF653002257A0925D8EB0C64EBBE8CC7DE87F548D107DE1FD3D1D285DB4F",
+		"",
+		0x29);
+	sk_UNK7_arr.emplace_back(0x0003007400000000, 0x0000, KEY_UNK7,
+		"F11DBD2C97B32AD37E55F8E743BC821D3E67630A6784D9A058DDD26313482F0F",
+		"FC5FA12CA3D2D336C4B8B425D679DA55",
+		"19E27EE90E33EDAB16B22E688B5F704E5C6EC1062070EBF43554CD03DFDAE16D684BB8B5574DBECA",
+		"",
+		0x15);
+	sk_UNK7_arr.emplace_back(0x0004001100000000, 0x0000, KEY_UNK7,
+		"751EE949CD3ADF50A469197494A1EC358409CCBE6E85217EBDE7A87D3FF1ABD8",
+		"23AE4ADA4D3F798DC5ED98000337FF77",
+		"1BABA87CD1AD705C462D4E7427B6DAF59A50383A348A15088F0EDFCF1ADF2B5C2B2D507B2A357D36",
+		"",
+		0x1A);
+	sk_UNK7_arr.emplace_back(0x0004004600000000, 0x0000, KEY_UNK7,
+		"46BD0891224E0CE13E2162921D4BB76193AEEE4416A729FCDD111C5536BF87C9",
+		"BF036387CDB613C0AC88A6D9D2CC5316",
+		"A14F6D5F9AD7EBB3B7A39A7C32F13E5DC3B0BA16BDC33D39FDDF88F4AEEA6CFEEB0C0796C917A952",
+		"",
+		0x0F);
+}
+
+SELF_KEY KeyVault::GetSelfLV0Key() const
+{
+	return sk_LV0_arr[0];
+}
+
+SELF_KEY KeyVault::GetSelfLDRKey() const
+{
+	return sk_LDR_arr[0];
+}
+
+SELF_KEY KeyVault::GetSelfLV1Key(u64 version) const
+{
+	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
+
+	for(unsigned int i = 0; i < sk_LV1_arr.size(); i++)
+	{
+		if (sk_LV1_arr[i].version == version)
+		{
+			key = sk_LV1_arr[i];
+			break;
+		}
+	}
+
+	return key;
+}
+
+SELF_KEY KeyVault::GetSelfLV2Key(u64 version) const
+{
+	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
+
+	for(unsigned int i = 0; i < sk_LV2_arr.size(); i++)
+	{
+		if (sk_LV2_arr[i].version == version)
+		{
+			key = sk_LV2_arr[i];
+			break;
+		}
+	}
+
+	return key;
+}
+
+SELF_KEY KeyVault::GetSelfISOKey(u16 revision, u64 version) const
+{
+	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
+
+	for(unsigned int i = 0; i < sk_ISO_arr.size(); i++)
+	{
+		if ((sk_ISO_arr[i].version == version) &&
+			(sk_ISO_arr[i].revision == revision))
+		{
+			key = sk_ISO_arr[i];
+			break;
+		}
+	}
+
+	return key;
+}
+
+SELF_KEY KeyVault::GetSelfAPPKey(u16 revision) const
+{
+	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
+
+	for(unsigned int i = 0; i < sk_APP_arr.size(); i++)
+	{
+		if (sk_APP_arr[i].revision == revision)
+		{
+			key = sk_APP_arr[i];
+			break;
+		}
+	}
+
+	return key;
+}
+
+SELF_KEY KeyVault::GetSelfUNK7Key(u64 version) const
+{
+	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
+
+	for(unsigned int i = 0; i < sk_UNK7_arr.size(); i++)
+	{
+		if (sk_UNK7_arr[i].version == version)
+		{
+			key = sk_UNK7_arr[i];
+			break;
+		}
+	}
+
+	return key;
+}
+
+SELF_KEY KeyVault::GetSelfNPDRMKey(u16 revision) const
+{
+	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
+
+	for(unsigned int i = 0; i < sk_NPDRM_arr.size(); i++)
+	{
+		if (sk_NPDRM_arr[i].revision == revision)
+		{
+			key = sk_NPDRM_arr[i];
+			break;
+		}
+	}
+
+	return key;
+}
+
+SELF_KEY KeyVault::FindSelfKey(u32 type, u16 revision, u64 version)
+{
+	// Empty key.
+	SELF_KEY key(0, 0, 0, "", "", "", "", 0);
+
+	// Check SELF type.
+	switch (type)
+	{
+	case KEY_LV0:
+		LoadSelfLV0Keys();
+		key = GetSelfLV0Key();
+		break;
+	case KEY_LV1:
+		LoadSelfLV1Keys();
+		key = GetSelfLV1Key(version);
+		break;
+	case KEY_LV2:
+		LoadSelfLV2Keys();
+		key = GetSelfLV2Key(version);
+		break;
+	case KEY_APP:
+		LoadSelfAPPKeys();
+		key = GetSelfAPPKey(revision);
+		break;
+	case KEY_ISO:
+		LoadSelfISOKeys();
+		key = GetSelfISOKey(revision, version);
+		break;
+	case KEY_LDR:
+		LoadSelfLDRKeys();
+		key = GetSelfLDRKey();
+		break;
+	case KEY_UNK7:
+		LoadSelfUNK7Keys();
+		key = GetSelfUNK7Key(version);
+		break;
+	case KEY_NPDRM:
+		LoadSelfNPDRMKeys();
+		key = GetSelfNPDRMKey(revision);
+		break;
+	default:
+		break;
+	}
+
+	return key;
+}
+
+void KeyVault::SetKlicenseeKey(u8 *key)
+{
+	memcpy(klicensee_key, key, 0x10);
+}
+
+u8 *KeyVault::GetKlicenseeKey()
+{
+	return klicensee_key;
+}
+
+void rap_to_rif(unsigned char* rap, unsigned char* rif)
+{
+	int i;
+	int round;
+	aes_context aes;
+
+	unsigned char key[0x10];
+	unsigned char iv[0x10];
+	memset(key, 0, 0x10);
+	memset(iv, 0, 0x10);
+
+	// Initial decrypt.
+	aes_setkey_dec(&aes, RAP_KEY, 128);
+	aes_crypt_cbc(&aes, AES_DECRYPT, 0x10, iv, rap, key);
+
+	// rap2rifkey round.
+	for (round = 0; round < 5; ++round)
+	{
+		for (i = 0; i < 16; ++i)
+		{
+			int p = RAP_PBOX[i];
+			key[p] ^= RAP_E1[p];
+		}
+		for (i = 15; i >= 1; --i)
+		{
+			int p = RAP_PBOX[i];
+			int pp = RAP_PBOX[i - 1];
+			key[p] ^= key[pp];
+		}
+		int o = 0;
+		for (i = 0; i < 16; ++i)
+		{
+			int p = RAP_PBOX[i];
+			unsigned char kc = key[p] - o;
+			unsigned char ec2 = RAP_E2[p];
+			if (o != 1 || kc != 0xFF)
+			{
+				o = kc < ec2 ? 1 : 0;
+				key[p] = kc - ec2;
+			} else if (kc == 0xFF)
+			{
+				key[p] = kc - ec2;
+			} else
+			{
+				key[p] = kc;
+			}
+		}
+	}
+
+	memcpy(rif, key, 0x10);
+}
+

rpcs3/Crypto/key_vault.h

@@ -0,0 +1,178 @@
+#pragma once
+
+enum SELF_KEY_TYPE {
+	KEY_LV0 = 1,
+	KEY_LV1,
+	KEY_LV2,
+	KEY_APP,
+	KEY_ISO,
+	KEY_LDR,
+	KEY_UNK7,
+    KEY_NPDRM
+};
+
+struct SELF_KEY {
+	u64 version;
+	u16 revision;
+	u32 self_type;
+	u8 erk[0x20];
+	u8 riv[0x10];
+	u8 pub[0x28];
+	u8 priv[0x15];
+	u32 curve_type;
+
+	SELF_KEY(u64 ver, u16 rev, u32 type, const std::string& e, const std::string& r, const std::string& pb, const std::string& pr, u32 ct);
+};
+
+static u8 PKG_AES_KEY[0x10] = {
+	0x2e, 0x7b, 0x71, 0xd7, 0xc9, 0xc9, 0xa1, 0x4e, 0xa3, 0x22, 0x1f, 0x18, 0x88, 0x28, 0xb8, 0xf8
+};
+
+static u8 PKG_AES_KEY2[0x10] = {
+	0x07, 0xf2, 0xc6, 0x82, 0x90, 0xb5, 0x0d, 0x2c, 0x33, 0x81, 0x8d, 0x70, 0x9b, 0x60, 0xe6, 0x2b
+};
+
+static u8 NP_IDPS[0x10] = {
+	0x5E, 0x06, 0xE0, 0x4F, 0xD9, 0x4A, 0x71, 0xBF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
+};
+
+static u8 NP_KLIC_FREE[0x10] = {
+	0x72, 0xF9, 0x90, 0x78, 0x8F, 0x9C, 0xFF, 0x74, 0x57, 0x25, 0xF0, 0x8E, 0x4C, 0x12, 0x83, 0x87
+};
+
+static u8 NP_OMAC_KEY_2[0x10] = {
+	0x6B, 0xA5, 0x29, 0x76, 0xEF, 0xDA, 0x16, 0xEF, 0x3C, 0x33, 0x9F, 0xB2, 0x97, 0x1E, 0x25, 0x6B
+};
+
+static u8 NP_OMAC_KEY_3[0x10] = {
+	0x9B, 0x51, 0x5F, 0xEA, 0xCF, 0x75, 0x06, 0x49, 0x81, 0xAA, 0x60, 0x4D, 0x91, 0xA5, 0x4E, 0x97
+};
+
+static u8 NP_KLIC_KEY[0x10] = {
+	0xF2, 0xFB, 0xCA, 0x7A, 0x75, 0xB0, 0x4E, 0xDC, 0x13, 0x90, 0x63, 0x8C, 0xCD, 0xFD, 0xD1, 0xEE
+};
+
+static u8 NP_RIF_KEY[0x10] = {
+	0xDA, 0x7D, 0x4B, 0x5E, 0x49, 0x9A, 0x4F, 0x53, 0xB1, 0xC1, 0xA1, 0x4A, 0x74, 0x84, 0x44, 0x3B
+};
+
+static u8 NP_PSP_KEY_1[0x10] = {
+	0x2A, 0x6A, 0xFB, 0xCF, 0x43, 0xD1, 0x57, 0x9F, 0x7D, 0x73, 0x87, 0x41, 0xA1, 0x3B, 0xD4, 0x2E
+};
+
+static u8 NP_PSP_KEY_2[0x10] = {
+	0x0D, 0xB8, 0x57, 0x32, 0x36, 0x6C, 0xD7, 0x34, 0xFC, 0x87, 0x9E, 0x74, 0x33, 0x43, 0xBB, 0x4F
+};
+
+static u8 NP_PSX_KEY[0x10] = {
+	0x52, 0xC0, 0xB5, 0xCA, 0x76, 0xD6, 0x13, 0x4B, 0xB4, 0x5F, 0xC6, 0x6C, 0xA6, 0x37, 0xF2, 0xC1
+};
+
+static u8 RAP_KEY[0x10] = {
+	0x86, 0x9F, 0x77, 0x45, 0xC1, 0x3F, 0xD8, 0x90, 0xCC, 0xF2, 0x91, 0x88, 0xE3, 0xCC, 0x3E, 0xDF
+};
+
+static u8 RAP_PBOX[0x10] = {
+	0x0C, 0x03, 0x06, 0x04, 0x01, 0x0B, 0x0F, 0x08, 0x02, 0x07, 0x00, 0x05, 0x0A, 0x0E, 0x0D, 0x09
+};
+
+static u8 RAP_E1[0x10] = {
+	0xA9, 0x3E, 0x1F, 0xD6, 0x7C, 0x55, 0xA3, 0x29, 0xB7, 0x5F, 0xDD, 0xA6, 0x2A, 0x95, 0xC7, 0xA5
+};
+
+static u8 RAP_E2[0x10] = {
+	0x67, 0xD4, 0x5D, 0xA3, 0x29, 0x6D, 0x00, 0x6A, 0x4E, 0x7C, 0x53, 0x7B, 0xF5, 0x53, 0x8C, 0x74
+};
+
+static u8 SDAT_KEY[0x10] = {
+	0x0D, 0x65, 0x5E, 0xF8, 0xE6, 0x74, 0xA9, 0x8A, 0xB8, 0x50, 0x5C, 0xFA, 0x7D, 0x01, 0x29, 0x33
+};
+
+static u8 EDAT_KEY_0[0x10] = {
+	0xBE, 0x95, 0x9C, 0xA8, 0x30, 0x8D, 0xEF, 0xA2, 0xE5, 0xE1, 0x80, 0xC6, 0x37, 0x12, 0xA9, 0xAE
+};
+
+static u8 EDAT_HASH_0[0x10] = {
+	0xEF, 0xFE, 0x5B, 0xD1, 0x65, 0x2E, 0xEB, 0xC1, 0x19, 0x18, 0xCF, 0x7C, 0x04, 0xD4, 0xF0, 0x11
+};
+
+static u8 EDAT_KEY_1[0x10] = {
+	0x4C, 0xA9, 0xC1, 0x4B, 0x01, 0xC9, 0x53, 0x09, 0x96, 0x9B, 0xEC, 0x68, 0xAA, 0x0B, 0xC0, 0x81
+};
+
+static u8 EDAT_HASH_1[0x10] = {
+	0x3D, 0x92, 0x69, 0x9B, 0x70, 0x5B, 0x07, 0x38, 0x54, 0xD8, 0xFC, 0xC6, 0xC7, 0x67, 0x27, 0x47
+};
+
+static u8 EDAT_IV[0x10] = {
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+static u8 VSH_CURVE_P[0x14] = {
+	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
+};
+
+static u8 VSH_CURVE_A[0x14] = {
+	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC
+};
+
+static u8 VSH_CURVE_B[0x14] = {
+	0xA6, 0x8B, 0xED, 0xC3, 0x34, 0x18, 0x02, 0x9C, 0x1D, 0x3C, 0xE3, 0x3B, 0x9A, 0x32, 0x1F, 0xCC, 0xBB, 0x9E, 0x0F, 0x0B
+};
+
+static u8 VSH_CURVE_N[0x15] = {
+	0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xB5, 0xAE, 0x3C, 0x52, 0x3E, 0x63, 0x94, 0x4F, 0x21, 0x27
+};
+
+static u8 VSH_CURVE_GX[0x14] = {
+	0x12, 0x8E, 0xC4, 0x25, 0x64, 0x87, 0xFD, 0x8F, 0xDF, 0x64, 0xE2, 0x43, 0x7B, 0xC0, 0xA1, 0xF6, 0xD5, 0xAF, 0xDE, 0x2C
+};
+
+static u8 VSH_CURVE_GY[0x14] = {
+	0x59, 0x58, 0x55, 0x7E, 0xB1, 0xDB, 0x00, 0x12, 0x60, 0x42, 0x55, 0x24, 0xDB, 0xC3, 0x79, 0xD5, 0xAC, 0x5F, 0x4A, 0xDF
+};
+
+static u8 VSH_PUB[0x28] = {
+	0x62, 0x27, 0xB0, 0x0A, 0x02, 0x85, 0x6F, 0xB0, 0x41, 0x08, 0x87, 0x67, 0x19, 0xE0, 0xA0, 0x18, 0x32, 0x91, 0xEE, 0xB9,
+	0x6E, 0x73, 0x6A, 0xBF, 0x81, 0xF7, 0x0E, 0xE9, 0x16, 0x1B, 0x0D, 0xDE, 0xB0, 0x26, 0x76, 0x1A, 0xFF, 0x7B, 0xC8, 0x5B
+};
+
+class KeyVault
+{
+	std::vector<SELF_KEY> sk_LV0_arr;
+	std::vector<SELF_KEY> sk_LV1_arr;
+	std::vector<SELF_KEY> sk_LV2_arr;
+	std::vector<SELF_KEY> sk_APP_arr;
+	std::vector<SELF_KEY> sk_ISO_arr;
+	std::vector<SELF_KEY> sk_LDR_arr;
+	std::vector<SELF_KEY> sk_UNK7_arr;
+	std::vector<SELF_KEY> sk_NPDRM_arr;
+	u8 klicensee_key[0x10];
+
+public:
+	KeyVault();
+	SELF_KEY FindSelfKey(u32 type, u16 revision, u64 version);
+	void SetKlicenseeKey(u8 *key);
+	u8 *GetKlicenseeKey();
+
+private:	
+	void LoadSelfLV0Keys();
+	void LoadSelfLDRKeys();
+	void LoadSelfLV1Keys();
+	void LoadSelfLV2Keys();
+	void LoadSelfISOKeys();
+	void LoadSelfAPPKeys();
+	void LoadSelfUNK7Keys();
+	void LoadSelfNPDRMKeys();
+	SELF_KEY GetSelfLV0Key() const;
+	SELF_KEY GetSelfLDRKey() const;
+	SELF_KEY GetSelfLV1Key(u64 version) const;
+	SELF_KEY GetSelfLV2Key(u64 version) const;
+	SELF_KEY GetSelfISOKey(u16 revision, u64 version) const;
+	SELF_KEY GetSelfAPPKey(u16 revision) const;
+	SELF_KEY GetSelfUNK7Key(u64 version) const;
+	SELF_KEY GetSelfNPDRMKey(u16 revision) const;
+};
+
+// RAP to RIF function.
+void rap_to_rif(unsigned char* rap, unsigned char* rif);

rpcs3/Crypto/lz.cpp

@@ -0,0 +1,278 @@
+// Copyright (C) 2014       Hykem <hykem@hotmail.com>
+// Licensed under the terms of the GNU GPL, version 3
+// http://www.gnu.org/licenses/gpl-3.0.txt
+
+#include "lz.h"
+
+void decode_range(unsigned int *range, unsigned int *code, unsigned char **src)
+{
+	if (!((*range) >> 24)) 
+	{
+		(*range) <<= 8;
+		*code = ((*code) << 8) + (*src)++[5];
+	}
+}
+
+int decode_bit(unsigned int *range, unsigned int *code, int *index, unsigned char **src, unsigned char *c)
+{
+	decode_range(range, code, src);
+	
+	unsigned int val = ((*range) >> 8) * (*c);
+
+	*c -= ((*c) >> 3);
+	if (index) (*index) <<= 1;
+
+	if (*code < val)
+	{
+		*range = val;
+		*c += 31;
+		if (index) (*index)++;
+		return 1;
+	}
+	else
+	{
+		*code -= val;
+		*range -= val;
+		return 0;
+	}
+}
+
+int decode_number(unsigned char *ptr, int index, int *bit_flag, unsigned int *range, unsigned int *code, unsigned char **src)
+{
+	int i = 1;
+
+	if (index >= 3) 
+	{
+		decode_bit(range, code, &i, src, ptr + 0x18);
+		if (index >= 4) 
+		{
+			decode_bit(range, code, &i, src, ptr + 0x18);
+			if (index >= 5)
+			{
+				decode_range(range, code, src);
+				for (; index >= 5; index--)
+				{
+					i <<= 1;
+					(*range) >>= 1;
+					if (*code < *range) 
+						i++; 
+					else
+						(*code) -= *range;
+				}
+			}
+		}
+	}
+
+	*bit_flag = decode_bit(range, code, &i, src, ptr);
+
+	if (index >= 1) 
+	{
+		decode_bit(range, code, &i, src, ptr + 0x8);
+		if (index >= 2) 
+		{
+			decode_bit(range, code, &i, src, ptr + 0x10);
+		}
+	}	
+
+	return i;
+}
+
+int decode_word(unsigned char *ptr, int index, int *bit_flag, unsigned int *range, unsigned int *code, unsigned char **src)
+{
+	int i = 1;
+	index /= 8;
+
+	if (index >= 3) 
+	{
+		decode_bit(range, code, &i, src, ptr + 4);
+		if (index >= 4) 
+		{
+			decode_bit(range, code, &i, src, ptr + 4);
+			if (index >= 5)
+			{
+				decode_range(range, code, src);
+				for (; index >= 5; index--)
+				{
+					i <<= 1;
+					(*range) >>= 1;
+					if (*code < *range) 
+						i++; 
+					else
+						(*code) -= *range;
+				}
+			}
+		}
+	}
+
+	*bit_flag = decode_bit(range, code, &i, src, ptr);
+
+	if (index >= 1) 
+	{
+		decode_bit(range, code, &i, src, ptr + 1);
+		if (index >= 2) 
+		{
+			decode_bit(range, code, &i, src, ptr + 2);
+		}
+	}	
+
+	return i;
+}
+
+int decompress(unsigned char *out, unsigned char *in, unsigned int size)
+{
+	int result;
+
+	unsigned char *tmp = new unsigned char[0xCC8];
+
+	int offset = 0;
+	int bit_flag = 0;
+	int data_length = 0;
+	int data_offset = 0;
+
+	unsigned char *tmp_sect1, *tmp_sect2, *tmp_sect3;
+	unsigned char *buf_start, *buf_end;
+	unsigned char prev = 0;
+
+	unsigned char *start = out;
+	unsigned char *end = (out + size);
+	unsigned char head = in[0];
+
+	unsigned int range = 0xFFFFFFFF;
+	unsigned int code = (in[1] << 24) | (in[2] << 16) | (in[3] << 8) | in[4];
+
+	// TODO:: Syphurith: There was a check against the unsigned char head. if (head < 0) would always be false.. I don't know are you tried to if (head > 0x80)?
+	if (head < 0) // Check if we have a valid starting byte.
+	{
+		// The dictionary header is invalid, the data is not compressed.
+		result = -1;
+		if (code <= size)
+		{
+			memcpy(out, (const void *)(in + 5), code);
+			result = (start - out);
+		}
+	}
+	else
+	{
+		// Set up a temporary buffer (sliding window).
+		memset(tmp, 0x80, 0xCA8);
+		while (1)
+		{
+			// Start reading at 0xB68.
+			tmp_sect1 = tmp + offset + 0xB68;
+			if (!decode_bit(&range, &code, 0, &in, tmp_sect1))  // Raw char.
+			{
+				// Adjust offset and check for stream end.
+				if (offset > 0) offset--;
+				if (start == end) return (start - out);
+
+				// Locate first section.
+				int sect = (((((((int)(start - out)) & 7) << 8) + prev) >> head) & 7) * 0xFF - 1;
+				tmp_sect1 = tmp + sect;
+				int index = 1;
+
+				// Read, decode and write back.
+				do
+				{
+					decode_bit(&range, &code, &index, &in, tmp_sect1 + index);
+				} while ((index >> 8) == 0);
+
+				// Save index.
+				*start++ = index;
+			}
+			else  // Compressed char stream.
+			{
+				int index = -1;
+
+				// Identify the data length bit field.
+				do
+				{
+					tmp_sect1 += 8; 
+					bit_flag = decode_bit(&range, &code, 0, &in, tmp_sect1);
+					index += bit_flag;
+				} while ((bit_flag != 0) && (index < 6));
+
+				// Default block size is 0x160.
+				int b_size = 0x160;
+				tmp_sect2 = tmp + index + 0x7F1;
+
+				// If the data length was found, parse it as a number.
+				if ((index >= 0) || (bit_flag != 0)) 
+				{
+					// Locate next section.
+					int sect = (index << 5) | (((((int)(start - out)) << index) & 3) << 3) | (offset & 7);
+					tmp_sect1 = tmp + 0xBA8 + sect;
+
+					// Decode the data length (8 bit fields).
+					data_length = decode_number(tmp_sect1, index, &bit_flag, &range, &code, &in);
+					if (data_length == 0xFF) return (start - out);  // End of stream.		
+				}
+				else 
+				{
+					// Assume one byte of advance.
+					data_length = 1;
+				}
+
+				// If we got valid parameters, seek to find data offset.
+				if ((data_length <= 2))
+				{
+					tmp_sect2 += 0xF8;
+					b_size = 0x40;  // Block size is now 0x40.
+				}
+
+				int diff = 0;
+				int shift = 1;
+
+				// Identify the data offset bit field.
+				do
+				{
+					diff = (shift << 4) - b_size;
+					bit_flag = decode_bit(&range, &code, &shift, &in, tmp_sect2 + (shift << 3));
+				} while (diff < 0);
+
+				// If the data offset was found, parse it as a number.
+				if ((diff > 0) || (bit_flag != 0)) 
+				{
+					// Adjust diff if needed.
+					if (bit_flag == 0) diff -= 8;
+
+					// Locate section.
+					tmp_sect3 = tmp + 0x928 + diff;
+
+					// Decode the data offset (1 bit fields).
+					data_offset = decode_word(tmp_sect3, diff, &bit_flag, &range, &code, &in);
+				}
+				else
+				{
+					// Assume one byte of advance.
+					data_offset = 1;
+				}
+
+				// Set buffer start/end.
+				buf_start = start - data_offset;
+				buf_end = start + data_length + 1;
+
+				// Underflow.
+				if (buf_start < out)
+					return -1;
+
+				// Overflow.
+				if (buf_end > end)
+					return -1;
+
+				// Update offset.
+				offset = ((((int)(buf_end - out)) + 1) & 1) + 6;
+
+				// Copy data.
+				do
+				{
+					*start++ = *buf_start++;
+				} while (start < buf_end);
+
+			}
+			prev = *(start - 1);
+		}
+		result = (start - out);
+	}
+	delete[] tmp;
+	return result;
+}

rpcs3/Crypto/lz.h

@@ -0,0 +1,15 @@
+#pragma once
+
+// Copyright (C) 2014       Hykem <hykem@hotmail.com>
+// Licensed under the terms of the GNU GPL, version 3
+// http://www.gnu.org/licenses/gpl-3.0.txt
+
+// Reverse-engineered custom Lempel–Ziv–Markov based compression.
+
+#include <string.h>
+
+void decode_range(unsigned int *range, unsigned int *code, unsigned char **src);
+int decode_bit(unsigned int *range, unsigned int *code, int *index, unsigned char **src, unsigned char *c);
+int decode_number(unsigned char *ptr, int index, int *bit_flag, unsigned int *range, unsigned int *code, unsigned char **src);
+int decode_word(unsigned char *ptr, int index, int *bit_flag, unsigned int *range, unsigned int *code, unsigned char **src);
+int decompress(unsigned char *out, unsigned char *in, unsigned int size);

rpcs3/Crypto/sha1.cpp

@@ -0,0 +1,397 @@
+/*
+ *  FIPS-180-1 compliant SHA-1 implementation
+ *
+ *  Copyright (C) 2006-2013, Brainspark B.V.
+ *
+ *  This file is part of PolarSSL (http://www.polarssl.org)
+ *  Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
+ *
+ *  All rights reserved.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  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 for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+/*
+ *  The SHA-1 standard was published by NIST in 1993.
+ *
+ *  http://www.itl.nist.gov/fipspubs/fip180-1.htm
+ */
+ 
+#include "stdafx.h"
+#include "sha1.h"
+
+/*
+ * 32-bit integer manipulation macros (big endian)
+ */
+#ifndef GET_UINT32_BE
+#define GET_UINT32_BE(n,b,i)                            \
+{                                                       \
+    (n) = ( (uint32_t) (b)[(i)    ] << 24 )             \
+        | ( (uint32_t) (b)[(i) + 1] << 16 )             \
+        | ( (uint32_t) (b)[(i) + 2] <<  8 )             \
+        | ( (uint32_t) (b)[(i) + 3]       );            \
+}
+#endif
+
+#ifndef PUT_UINT32_BE
+#define PUT_UINT32_BE(n,b,i)                            \
+{                                                       \
+    (b)[(i)    ] = (unsigned char) ( (n) >> 24 );       \
+    (b)[(i) + 1] = (unsigned char) ( (n) >> 16 );       \
+    (b)[(i) + 2] = (unsigned char) ( (n) >>  8 );       \
+    (b)[(i) + 3] = (unsigned char) ( (n)       );       \
+}
+#endif
+
+/*
+ * SHA-1 context setup
+ */
+void sha1_starts( sha1_context *ctx )
+{
+    ctx->total[0] = 0;
+    ctx->total[1] = 0;
+
+    ctx->state[0] = 0x67452301;
+    ctx->state[1] = 0xEFCDAB89;
+    ctx->state[2] = 0x98BADCFE;
+    ctx->state[3] = 0x10325476;
+    ctx->state[4] = 0xC3D2E1F0;
+}
+
+void sha1_process( sha1_context *ctx, const unsigned char data[64] )
+{
+    uint32_t temp, W[16], A, B, C, D, E;
+
+    GET_UINT32_BE( W[ 0], data,  0 );
+    GET_UINT32_BE( W[ 1], data,  4 );
+    GET_UINT32_BE( W[ 2], data,  8 );
+    GET_UINT32_BE( W[ 3], data, 12 );
+    GET_UINT32_BE( W[ 4], data, 16 );
+    GET_UINT32_BE( W[ 5], data, 20 );
+    GET_UINT32_BE( W[ 6], data, 24 );
+    GET_UINT32_BE( W[ 7], data, 28 );
+    GET_UINT32_BE( W[ 8], data, 32 );
+    GET_UINT32_BE( W[ 9], data, 36 );
+    GET_UINT32_BE( W[10], data, 40 );
+    GET_UINT32_BE( W[11], data, 44 );
+    GET_UINT32_BE( W[12], data, 48 );
+    GET_UINT32_BE( W[13], data, 52 );
+    GET_UINT32_BE( W[14], data, 56 );
+    GET_UINT32_BE( W[15], data, 60 );
+
+#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
+
+#define R(t)                                            \
+(                                                       \
+    temp = W[(t -  3) & 0x0F] ^ W[(t - 8) & 0x0F] ^     \
+           W[(t - 14) & 0x0F] ^ W[ t      & 0x0F],      \
+    ( W[t & 0x0F] = S(temp,1) )                         \
+)
+
+#define P(a,b,c,d,e,x)                                  \
+{                                                       \
+    e += S(a,5) + F(b,c,d) + K + x; b = S(b,30);        \
+}
+
+    A = ctx->state[0];
+    B = ctx->state[1];
+    C = ctx->state[2];
+    D = ctx->state[3];
+    E = ctx->state[4];
+
+#define F(x,y,z) (z ^ (x & (y ^ z)))
+#define K 0x5A827999
+
+    P( A, B, C, D, E, W[0]  );
+    P( E, A, B, C, D, W[1]  );
+    P( D, E, A, B, C, W[2]  );
+    P( C, D, E, A, B, W[3]  );
+    P( B, C, D, E, A, W[4]  );
+    P( A, B, C, D, E, W[5]  );
+    P( E, A, B, C, D, W[6]  );
+    P( D, E, A, B, C, W[7]  );
+    P( C, D, E, A, B, W[8]  );
+    P( B, C, D, E, A, W[9]  );
+    P( A, B, C, D, E, W[10] );
+    P( E, A, B, C, D, W[11] );
+    P( D, E, A, B, C, W[12] );
+    P( C, D, E, A, B, W[13] );
+    P( B, C, D, E, A, W[14] );
+    P( A, B, C, D, E, W[15] );
+    P( E, A, B, C, D, R(16) );
+    P( D, E, A, B, C, R(17) );
+    P( C, D, E, A, B, R(18) );
+    P( B, C, D, E, A, R(19) );
+
+#undef K
+#undef F
+
+#define F(x,y,z) (x ^ y ^ z)
+#define K 0x6ED9EBA1
+
+    P( A, B, C, D, E, R(20) );
+    P( E, A, B, C, D, R(21) );
+    P( D, E, A, B, C, R(22) );
+    P( C, D, E, A, B, R(23) );
+    P( B, C, D, E, A, R(24) );
+    P( A, B, C, D, E, R(25) );
+    P( E, A, B, C, D, R(26) );
+    P( D, E, A, B, C, R(27) );
+    P( C, D, E, A, B, R(28) );
+    P( B, C, D, E, A, R(29) );
+    P( A, B, C, D, E, R(30) );
+    P( E, A, B, C, D, R(31) );
+    P( D, E, A, B, C, R(32) );
+    P( C, D, E, A, B, R(33) );
+    P( B, C, D, E, A, R(34) );
+    P( A, B, C, D, E, R(35) );
+    P( E, A, B, C, D, R(36) );
+    P( D, E, A, B, C, R(37) );
+    P( C, D, E, A, B, R(38) );
+    P( B, C, D, E, A, R(39) );
+
+#undef K
+#undef F
+
+#define F(x,y,z) ((x & y) | (z & (x | y)))
+#define K 0x8F1BBCDC
+
+    P( A, B, C, D, E, R(40) );
+    P( E, A, B, C, D, R(41) );
+    P( D, E, A, B, C, R(42) );
+    P( C, D, E, A, B, R(43) );
+    P( B, C, D, E, A, R(44) );
+    P( A, B, C, D, E, R(45) );
+    P( E, A, B, C, D, R(46) );
+    P( D, E, A, B, C, R(47) );
+    P( C, D, E, A, B, R(48) );
+    P( B, C, D, E, A, R(49) );
+    P( A, B, C, D, E, R(50) );
+    P( E, A, B, C, D, R(51) );
+    P( D, E, A, B, C, R(52) );
+    P( C, D, E, A, B, R(53) );
+    P( B, C, D, E, A, R(54) );
+    P( A, B, C, D, E, R(55) );
+    P( E, A, B, C, D, R(56) );
+    P( D, E, A, B, C, R(57) );
+    P( C, D, E, A, B, R(58) );
+    P( B, C, D, E, A, R(59) );
+
+#undef K
+#undef F
+
+#define F(x,y,z) (x ^ y ^ z)
+#define K 0xCA62C1D6
+
+    P( A, B, C, D, E, R(60) );
+    P( E, A, B, C, D, R(61) );
+    P( D, E, A, B, C, R(62) );
+    P( C, D, E, A, B, R(63) );
+    P( B, C, D, E, A, R(64) );
+    P( A, B, C, D, E, R(65) );
+    P( E, A, B, C, D, R(66) );
+    P( D, E, A, B, C, R(67) );
+    P( C, D, E, A, B, R(68) );
+    P( B, C, D, E, A, R(69) );
+    P( A, B, C, D, E, R(70) );
+    P( E, A, B, C, D, R(71) );
+    P( D, E, A, B, C, R(72) );
+    P( C, D, E, A, B, R(73) );
+    P( B, C, D, E, A, R(74) );
+    P( A, B, C, D, E, R(75) );
+    P( E, A, B, C, D, R(76) );
+    P( D, E, A, B, C, R(77) );
+    P( C, D, E, A, B, R(78) );
+    P( B, C, D, E, A, R(79) );
+
+#undef K
+#undef F
+
+    ctx->state[0] += A;
+    ctx->state[1] += B;
+    ctx->state[2] += C;
+    ctx->state[3] += D;
+    ctx->state[4] += E;
+}
+
+/*
+ * SHA-1 process buffer
+ */
+void sha1_update( sha1_context *ctx, const unsigned char *input, size_t ilen )
+{
+    size_t fill;
+    uint32_t left;
+
+    // TODO:: Syphurith: Orz. It is said that size_t is an unsigned type..
+    if( ilen <= 0 )
+        return;
+
+    left = ctx->total[0] & 0x3F;
+    fill = 64 - left;
+
+    ctx->total[0] += (uint32_t) ilen;
+    ctx->total[0] &= 0xFFFFFFFF;
+
+    if( ctx->total[0] < (uint32_t) ilen )
+        ctx->total[1]++;
+
+    if( left && ilen >= fill )
+    {
+        memcpy( (void *) (ctx->buffer + left), input, fill );
+        sha1_process( ctx, ctx->buffer );
+        input += fill;
+        ilen  -= fill;
+        left = 0;
+    }
+
+    while( ilen >= 64 )
+    {
+        sha1_process( ctx, input );
+        input += 64;
+        ilen  -= 64;
+    }
+
+    if( ilen > 0 )
+        memcpy( (void *) (ctx->buffer + left), input, ilen );
+}
+
+static const unsigned char sha1_padding[64] =
+{
+ 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+/*
+ * SHA-1 final digest
+ */
+void sha1_finish( sha1_context *ctx, unsigned char output[20] )
+{
+    uint32_t last, padn;
+    uint32_t high, low;
+    unsigned char msglen[8];
+
+    high = ( ctx->total[0] >> 29 )
+         | ( ctx->total[1] <<  3 );
+    low  = ( ctx->total[0] <<  3 );
+
+    PUT_UINT32_BE( high, msglen, 0 );
+    PUT_UINT32_BE( low,  msglen, 4 );
+
+    last = ctx->total[0] & 0x3F;
+    padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
+
+    sha1_update( ctx, sha1_padding, padn );
+    sha1_update( ctx, msglen, 8 );
+
+    PUT_UINT32_BE( ctx->state[0], output,  0 );
+    PUT_UINT32_BE( ctx->state[1], output,  4 );
+    PUT_UINT32_BE( ctx->state[2], output,  8 );
+    PUT_UINT32_BE( ctx->state[3], output, 12 );
+    PUT_UINT32_BE( ctx->state[4], output, 16 );
+}
+
+/*
+ * output = SHA-1( input buffer )
+ */
+void sha1( const unsigned char *input, size_t ilen, unsigned char output[20] )
+{
+    sha1_context ctx;
+
+    sha1_starts( &ctx );
+    sha1_update( &ctx, input, ilen );
+    sha1_finish( &ctx, output );
+
+    memset( &ctx, 0, sizeof( sha1_context ) );
+}
+
+/*
+ * SHA-1 HMAC context setup
+ */
+void sha1_hmac_starts( sha1_context *ctx, const unsigned char *key, size_t keylen )
+{
+    size_t i;
+    unsigned char sum[20];
+
+    if( keylen > 64 )
+    {
+        sha1( key, keylen, sum );
+        keylen = 20;
+        key = sum;
+    }
+
+    memset( ctx->ipad, 0x36, 64 );
+    memset( ctx->opad, 0x5C, 64 );
+
+    for( i = 0; i < keylen; i++ )
+    {
+        ctx->ipad[i] = (unsigned char)( ctx->ipad[i] ^ key[i] );
+        ctx->opad[i] = (unsigned char)( ctx->opad[i] ^ key[i] );
+    }
+
+    sha1_starts( ctx );
+    sha1_update( ctx, ctx->ipad, 64 );
+
+    memset( sum, 0, sizeof( sum ) );
+}
+
+/*
+ * SHA-1 HMAC process buffer
+ */
+void sha1_hmac_update( sha1_context *ctx, const unsigned char *input, size_t ilen )
+{
+    sha1_update( ctx, input, ilen );
+}
+
+/*
+ * SHA-1 HMAC final digest
+ */
+void sha1_hmac_finish( sha1_context *ctx, unsigned char output[20] )
+{
+    unsigned char tmpbuf[20];
+
+    sha1_finish( ctx, tmpbuf );
+    sha1_starts( ctx );
+    sha1_update( ctx, ctx->opad, 64 );
+    sha1_update( ctx, tmpbuf, 20 );
+    sha1_finish( ctx, output );
+
+    memset( tmpbuf, 0, sizeof( tmpbuf ) );
+}
+
+/*
+ * SHA1 HMAC context reset
+ */
+void sha1_hmac_reset( sha1_context *ctx )
+{
+    sha1_starts( ctx );
+    sha1_update( ctx, ctx->ipad, 64 );
+}
+
+/*
+ * output = HMAC-SHA-1( hmac key, input buffer )
+ */
+void sha1_hmac( const unsigned char *key, size_t keylen,
+                const unsigned char *input, size_t ilen,
+                unsigned char output[20] )
+{
+    sha1_context ctx;
+
+    sha1_hmac_starts( &ctx, key, keylen );
+    sha1_hmac_update( &ctx, input, ilen );
+    sha1_hmac_finish( &ctx, output );
+
+    memset( &ctx, 0, sizeof( sha1_context ) );
+}

rpcs3/Crypto/sha1.h

@@ -0,0 +1,163 @@
+#pragma once
+
+/**
+ * \file sha1.h
+ *
+ * \brief SHA-1 cryptographic hash function
+ *
+ *  Copyright (C) 2006-2013, Brainspark B.V.
+ *
+ *  This file is part of PolarSSL (http://www.polarssl.org)
+ *  Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
+ *
+ *  All rights reserved.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  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 for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include <string.h>
+
+#ifdef _MSC_VER
+#include <basetsd.h>
+typedef UINT32 uint32_t;
+#else
+#include <inttypes.h>
+#endif
+
+#define POLARSSL_ERR_SHA1_FILE_IO_ERROR                -0x0076  /**< Read/write error in file. */
+
+// Regular implementation
+//
+
+/**
+ * \brief          SHA-1 context structure
+ */
+typedef struct
+{
+    uint32_t total[2];          /*!< number of bytes processed  */
+    uint32_t state[5];          /*!< intermediate digest state  */
+    unsigned char buffer[64];   /*!< data block being processed */
+
+    unsigned char ipad[64];     /*!< HMAC: inner padding        */
+    unsigned char opad[64];     /*!< HMAC: outer padding        */
+}
+sha1_context;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \brief          SHA-1 context setup
+ *
+ * \param ctx      context to be initialized
+ */
+void sha1_starts( sha1_context *ctx );
+
+/**
+ * \brief          SHA-1 process buffer
+ *
+ * \param ctx      SHA-1 context
+ * \param input    buffer holding the  data
+ * \param ilen     length of the input data
+ */
+void sha1_update( sha1_context *ctx, const unsigned char *input, size_t ilen );
+
+/**
+ * \brief          SHA-1 final digest
+ *
+ * \param ctx      SHA-1 context
+ * \param output   SHA-1 checksum result
+ */
+void sha1_finish( sha1_context *ctx, unsigned char output[20] );
+
+/* Internal use */
+void sha1_process( sha1_context *ctx, const unsigned char data[64] );
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \brief          Output = SHA-1( input buffer )
+ *
+ * \param input    buffer holding the  data
+ * \param ilen     length of the input data
+ * \param output   SHA-1 checksum result
+ */
+void sha1( const unsigned char *input, size_t ilen, unsigned char output[20] );
+
+/**
+ * \brief          Output = SHA-1( file contents )
+ *
+ * \param path     input file name
+ * \param output   SHA-1 checksum result
+ *
+ * \return         0 if successful, or POLARSSL_ERR_SHA1_FILE_IO_ERROR
+ */
+int sha1_file( const char *path, unsigned char output[20] );
+
+/**
+ * \brief          SHA-1 HMAC context setup
+ *
+ * \param ctx      HMAC context to be initialized
+ * \param key      HMAC secret key
+ * \param keylen   length of the HMAC key
+ */
+void sha1_hmac_starts( sha1_context *ctx, const unsigned char *key, size_t keylen );
+
+/**
+ * \brief          SHA-1 HMAC process buffer
+ *
+ * \param ctx      HMAC context
+ * \param input    buffer holding the  data
+ * \param ilen     length of the input data
+ */
+void sha1_hmac_update( sha1_context *ctx, const unsigned char *input, size_t ilen );
+
+/**
+ * \brief          SHA-1 HMAC final digest
+ *
+ * \param ctx      HMAC context
+ * \param output   SHA-1 HMAC checksum result
+ */
+void sha1_hmac_finish( sha1_context *ctx, unsigned char output[20] );
+
+/**
+ * \brief          SHA-1 HMAC context reset
+ *
+ * \param ctx      HMAC context to be reset
+ */
+void sha1_hmac_reset( sha1_context *ctx );
+
+/**
+ * \brief          Output = HMAC-SHA-1( hmac key, input buffer )
+ *
+ * \param key      HMAC secret key
+ * \param keylen   length of the HMAC key
+ * \param input    buffer holding the  data
+ * \param ilen     length of the input data
+ * \param output   HMAC-SHA-1 result
+ */
+void sha1_hmac( const unsigned char *key, size_t keylen,
+                const unsigned char *input, size_t ilen,
+                unsigned char output[20] );
+
+#ifdef __cplusplus
+}
+#endif