Reformat all the things. Have fun with merge conflicts.

1 files changed, 575 insertions, 463 deletions

diff --git a/Source/Android/jni/MainAndroid.cpp b/Source/Android/jni/MainAndroid.cpp
index 6b30bc5409..796a2b5409 100644
--- a/Source/Android/jni/MainAndroid.cpp
+++ b/Source/Android/jni/MainAndroid.cpp
@@ -2,6 +2,9 @@
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
 
+#include <EGL/egl.h>
+#include <android/log.h>
+#include <android/native_window_jni.h>
 #include <cinttypes>
 #include <cstdio>
 #include <cstdlib>
@@ -9,15 +12,12 @@
 #include <memory>
 #include <mutex>
 #include <thread>
-#include <android/log.h>
-#include <android/native_window_jni.h>
-#include <EGL/egl.h>
 
 #include "ButtonManager.h"
 
+#include "Common/CPUDetect.h"
 #include "Common/CommonPaths.h"
 #include "Common/CommonTypes.h"
-#include "Common/CPUDetect.h"
 #include "Common/Event.h"
 #include "Common/FileUtil.h"
 #include "Common/GL/GLInterfaceBase.h"
@@ -26,12 +26,12 @@
 #include "Core/BootManager.h"
 #include "Core/ConfigManager.h"
 #include "Core/Core.h"
-#include "Core/Host.h"
-#include "Core/State.h"
 #include "Core/HW/Wiimote.h"
 #include "Core/HW/WiimoteReal/WiimoteReal.h"
+#include "Core/Host.h"
 #include "Core/PowerPC/JitInterface.h"
 #include "Core/PowerPC/Profiler.h"
+#include "Core/State.h"
 
 #include "DiscIO/Volume.h"
 #include "DiscIO/VolumeCreator.h"
@@ -58,13 +58,17 @@ jmethodID g_jni_method_end;
  */
 jint JNI_OnLoad(JavaVM* vm, void* reserved)
 {
-	g_java_vm = vm;
+  g_java_vm = vm;
 
-	return JNI_VERSION_1_6;
+  return JNI_VERSION_1_6;
 }
 
-void Host_NotifyMapLoaded() {}
-void Host_RefreshDSPDebuggerWindow() {}
+void Host_NotifyMapLoaded()
+{
+}
+void Host_RefreshDSPDebuggerWindow()
+{
+}
 
 // The Core only supports using a single Host thread.
 // If multiple threads want to call host functions then they need to queue
@@ -74,37 +78,43 @@ Common::Event updateMainFrameEvent;
 static bool s_have_wm_user_stop = false;
 void Host_Message(int Id)
 {
-	if (Id == WM_USER_JOB_DISPATCH)
-	{
-		updateMainFrameEvent.Set();
-	}
-	else if (Id == WM_USER_STOP)
-	{
-		s_have_wm_user_stop = true;
-		if (Core::IsRunning())
-			Core::QueueHostJob(&Core::Stop);
-	}
+  if (Id == WM_USER_JOB_DISPATCH)
+  {
+    updateMainFrameEvent.Set();
+  }
+  else if (Id == WM_USER_STOP)
+  {
+    s_have_wm_user_stop = true;
+    if (Core::IsRunning())
+      Core::QueueHostJob(&Core::Stop);
+  }
 }
 
 void* Host_GetRenderHandle()
 {
-	return surf;
+  return surf;
 }
 
 void Host_UpdateTitle(const std::string& title)
 {
-	__android_log_write(ANDROID_LOG_INFO, DOLPHIN_TAG, title.c_str());
+  __android_log_write(ANDROID_LOG_INFO, DOLPHIN_TAG, title.c_str());
 }
 
-void Host_UpdateDisasmDialog(){}
+void Host_UpdateDisasmDialog()
+{
+}
 
 void Host_UpdateMainFrame()
 {
 }
 
-void Host_RequestRenderWindowSize(int width, int height) {}
+void Host_RequestRenderWindowSize(int width, int height)
+{
+}
 
-void Host_RequestFullscreen(bool enable_fullscreen) {}
+void Host_RequestFullscreen(bool enable_fullscreen)
+{
+}
 
 void Host_SetStartupDebuggingParameters()
 {
@@ -112,614 +122,716 @@ void Host_SetStartupDebuggingParameters()
 
 bool Host_UIHasFocus()
 {
-	return true;
+  return true;
 }
 
 bool Host_RendererHasFocus()
 {
-	return true;
+  return true;
 }
 
 bool Host_RendererIsFullscreen()
 {
-	return false;
+  return false;
 }
 
-void Host_ConnectWiimote(int wm_idx, bool connect) {}
+void Host_ConnectWiimote(int wm_idx, bool connect)
+{
+}
 
-void Host_SetWiiMoteConnectionState(int _State) {}
+void Host_SetWiiMoteConnectionState(int _State)
+{
+}
 
-void Host_ShowVideoConfig(void*, const std::string&, const std::string&) {}
+void Host_ShowVideoConfig(void*, const std::string&, const std::string&)
+{
+}
 
 static bool MsgAlert(const char* caption, const char* text, bool yes_no, int /*Style*/)
 {
-	__android_log_print(ANDROID_LOG_ERROR, DOLPHIN_TAG, "%s:%s", caption, text);
+  __android_log_print(ANDROID_LOG_ERROR, DOLPHIN_TAG, "%s:%s", caption, text);
 
-	// Associate the current Thread with the Java VM.
-	JNIEnv* env;
-	g_java_vm->AttachCurrentThread(&env, NULL);
+  // Associate the current Thread with the Java VM.
+  JNIEnv* env;
+  g_java_vm->AttachCurrentThread(&env, NULL);
 
-	// Execute the Java method.
-	env->CallStaticVoidMethod(g_jni_class, g_jni_method_alert, env->NewStringUTF(text));
+  // Execute the Java method.
+  env->CallStaticVoidMethod(g_jni_class, g_jni_method_alert, env->NewStringUTF(text));
 
-	// Must be called before the current thread exits; might as well do it here.
-	g_java_vm->DetachCurrentThread();
+  // Must be called before the current thread exits; might as well do it here.
+  g_java_vm->DetachCurrentThread();
 
-	return false;
+  return false;
 }
 
 #define DVD_BANNER_WIDTH 96
 #define DVD_BANNER_HEIGHT 32
 
-static inline u32 Average32(u32 a, u32 b) {
-	return ((a >> 1) & 0x7f7f7f7f) + ((b >> 1) & 0x7f7f7f7f);
-}
-
-static inline u32 GetPixel(u32 *buffer, unsigned int x, unsigned int y) {
-	// thanks to unsignedness, these also check for <0 automatically.
-	if (x > 191) return 0;
-	if (y > 63) return 0;
-	return buffer[y * 192 + x];
-}
-
-static bool LoadBanner(std::string filename, u32 *Banner)
-{
-	std::unique_ptr<DiscIO::IVolume> pVolume(DiscIO::CreateVolumeFromFilename(filename));
-
-	if (pVolume != nullptr)
-	{
-		int Width, Height;
-		std::vector<u32> BannerVec = pVolume->GetBanner(&Width, &Height);
-		// This code (along with above inlines) is moved from
-		// elsewhere.  Someone who knows anything about Android
-		// please get rid of it and use proper high-resolution
-		// images.
-		if (Height == 64 && Width == 192)
-		{
-			u32* Buffer = &BannerVec[0];
-			for (int y = 0; y < 32; y++)
-			{
-				for (int x = 0; x < 96; x++)
-				{
-					// simplified plus-shaped "gaussian"
-					u32 surround = Average32(
-							Average32(GetPixel(Buffer, x*2 - 1, y*2), GetPixel(Buffer, x*2 + 1, y*2)),
-							Average32(GetPixel(Buffer, x*2, y*2 - 1), GetPixel(Buffer, x*2, y*2 + 1)));
-					Banner[y * 96 + x] = Average32(GetPixel(Buffer, x*2, y*2), surround);
-				}
-			}
-			return true;
-		}
-		else if (Height == 32 && Width == 96)
-		{
-			memcpy(Banner, &BannerVec[0], 96 * 32 * 4);
-			return true;
-		}
-	}
-
-	return false;
+static inline u32 Average32(u32 a, u32 b)
+{
+  return ((a >> 1) & 0x7f7f7f7f) + ((b >> 1) & 0x7f7f7f7f);
+}
+
+static inline u32 GetPixel(u32* buffer, unsigned int x, unsigned int y)
+{
+  // thanks to unsignedness, these also check for <0 automatically.
+  if (x > 191)
+    return 0;
+  if (y > 63)
+    return 0;
+  return buffer[y * 192 + x];
+}
+
+static bool LoadBanner(std::string filename, u32* Banner)
+{
+  std::unique_ptr<DiscIO::IVolume> pVolume(DiscIO::CreateVolumeFromFilename(filename));
+
+  if (pVolume != nullptr)
+  {
+    int Width, Height;
+    std::vector<u32> BannerVec = pVolume->GetBanner(&Width, &Height);
+    // This code (along with above inlines) is moved from
+    // elsewhere.  Someone who knows anything about Android
+    // please get rid of it and use proper high-resolution
+    // images.
+    if (Height == 64 && Width == 192)
+    {
+      u32* Buffer = &BannerVec[0];
+      for (int y = 0; y < 32; y++)
+      {
+        for (int x = 0; x < 96; x++)
+        {
+          // simplified plus-shaped "gaussian"
+          u32 surround = Average32(
+              Average32(GetPixel(Buffer, x * 2 - 1, y * 2), GetPixel(Buffer, x * 2 + 1, y * 2)),
+              Average32(GetPixel(Buffer, x * 2, y * 2 - 1), GetPixel(Buffer, x * 2, y * 2 + 1)));
+          Banner[y * 96 + x] = Average32(GetPixel(Buffer, x * 2, y * 2), surround);
+        }
+      }
+      return true;
+    }
+    else if (Height == 32 && Width == 96)
+    {
+      memcpy(Banner, &BannerVec[0], 96 * 32 * 4);
+      return true;
+    }
+  }
+
+  return false;
 }
 
 static int GetCountry(std::string filename)
 {
-	std::unique_ptr<DiscIO::IVolume> pVolume(DiscIO::CreateVolumeFromFilename(filename));
+  std::unique_ptr<DiscIO::IVolume> pVolume(DiscIO::CreateVolumeFromFilename(filename));
 
-	if (pVolume != nullptr)
-	{
-		DiscIO::IVolume::ECountry country = pVolume->GetCountry();
+  if (pVolume != nullptr)
+  {
+    DiscIO::IVolume::ECountry country = pVolume->GetCountry();
 
-		__android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Country Code: %i", country);
+    __android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Country Code: %i", country);
 
-		return country;
-	}
+    return country;
+  }
 
-	// Return UNKNOWN
-	return 13;
+  // Return UNKNOWN
+  return 13;
 }
 
 static int GetPlatform(std::string filename)
 {
-	std::unique_ptr<DiscIO::IVolume> pVolume(DiscIO::CreateVolumeFromFilename(filename));
+  std::unique_ptr<DiscIO::IVolume> pVolume(DiscIO::CreateVolumeFromFilename(filename));
 
-	if (pVolume != nullptr)
-	{
-		switch (pVolume->GetVolumeType())
-		{
-			case DiscIO::IVolume::GAMECUBE_DISC:
-				__android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Volume is a GameCube disc.");
-				return 0;
-			case DiscIO::IVolume::WII_DISC:
-				__android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Volume is a Wii disc.");
-				return 1;
-			case DiscIO::IVolume::WII_WAD:
-				__android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Volume is a Wii WAD.");
-				return 2;
-		}
-	}
+  if (pVolume != nullptr)
+  {
+    switch (pVolume->GetVolumeType())
+    {
+    case DiscIO::IVolume::GAMECUBE_DISC:
+      __android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Volume is a GameCube disc.");
+      return 0;
+    case DiscIO::IVolume::WII_DISC:
+      __android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Volume is a Wii disc.");
+      return 1;
+    case DiscIO::IVolume::WII_WAD:
+      __android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Volume is a Wii WAD.");
+      return 2;
+    }
+  }
 
-	return -1;
+  return -1;
 }
 
 static std::string GetTitle(std::string filename)
 {
-	__android_log_print(ANDROID_LOG_WARN, DOLPHIN_TAG, "Getting Title for file: %s", filename.c_str());
+  __android_log_print(ANDROID_LOG_WARN, DOLPHIN_TAG, "Getting Title for file: %s",
+                      filename.c_str());
 
-	std::unique_ptr<DiscIO::IVolume> pVolume(DiscIO::CreateVolumeFromFilename(filename));
+  std::unique_ptr<DiscIO::IVolume> pVolume(DiscIO::CreateVolumeFromFilename(filename));
 
-	if (pVolume != nullptr) {
-		std::map <DiscIO::IVolume::ELanguage, std::string> titles = pVolume->GetNames(true);
+  if (pVolume != nullptr)
+  {
+    std::map<DiscIO::IVolume::ELanguage, std::string> titles = pVolume->GetNames(true);
 
-		/*
-		bool is_wii_title = pVolume->GetVolumeType() != DiscIO::IVolume::GAMECUBE_DISC;
-		DiscIO::IVolume::ELanguage language = SConfig::GetInstance().GetCurrentLanguage(is_wii_title);
+    /*
+    bool is_wii_title = pVolume->GetVolumeType() != DiscIO::IVolume::GAMECUBE_DISC;
+    DiscIO::IVolume::ELanguage language = SConfig::GetInstance().GetCurrentLanguage(is_wii_title);
 
-		auto it = titles.find(language);
-		if (it != end)
-			return it->second;*/
+    auto it = titles.find(language);
+    if (it != end)
+      return it->second;*/
 
-		auto end = titles.end();
+    auto end = titles.end();
 
-		// English tends to be a good fallback when the requested language isn't available
-		//if (language != DiscIO::IVolume::ELanguage::LANGUAGE_ENGLISH) {
-			auto it = titles.find(DiscIO::IVolume::ELanguage::LANGUAGE_ENGLISH);
-			if (it != end)
-				return it->second;
-		//}
+    // English tends to be a good fallback when the requested language isn't available
+    // if (language != DiscIO::IVolume::ELanguage::LANGUAGE_ENGLISH) {
+    auto it = titles.find(DiscIO::IVolume::ELanguage::LANGUAGE_ENGLISH);
+    if (it != end)
+      return it->second;
+    //}
 
+    // If English isn't available either, just pick something
+    if (!titles.empty())
+      return titles.cbegin()->second;
 
-		// If English isn't available either, just pick something
-		if (!titles.empty())
-			return titles.cbegin()->second;
+    // No usable name, return filename (better than nothing)
+    std::string name;
+    SplitPath(filename, nullptr, &name, nullptr);
+    return name;
+  }
 
-		// No usable name, return filename (better than nothing)
-		std::string name;
-		SplitPath(filename, nullptr, &name, nullptr);
-		return name;
-	}
-
-	return std::string ("");
+  return std::string("");
 }
 
 static std::string GetDescription(std::string filename)
 {
-	__android_log_print(ANDROID_LOG_WARN, DOLPHIN_TAG, "Getting Description for file: %s", filename.c_str());
+  __android_log_print(ANDROID_LOG_WARN, DOLPHIN_TAG, "Getting Description for file: %s",
+                      filename.c_str());
 
-	std::unique_ptr<DiscIO::IVolume> volume(DiscIO::CreateVolumeFromFilename(filename));
+  std::unique_ptr<DiscIO::IVolume> volume(DiscIO::CreateVolumeFromFilename(filename));
 
-	if (volume != nullptr)
-	{
-		std::map<DiscIO::IVolume::ELanguage, std::string> descriptions = volume->GetDescriptions();
+  if (volume != nullptr)
+  {
+    std::map<DiscIO::IVolume::ELanguage, std::string> descriptions = volume->GetDescriptions();
 
-		/*
-		bool is_wii_title = pVolume->GetVolumeType() != DiscIO::IVolume::GAMECUBE_DISC;
-		DiscIO::IVolume::ELanguage language = SConfig::GetInstance().GetCurrentLanguage(is_wii_title);
+    /*
+    bool is_wii_title = pVolume->GetVolumeType() != DiscIO::IVolume::GAMECUBE_DISC;
+    DiscIO::IVolume::ELanguage language = SConfig::GetInstance().GetCurrentLanguage(is_wii_title);
 
-		auto it = descriptions.find(language);
-		if (it != end)
-			return it->second;*/
+    auto it = descriptions.find(language);
+    if (it != end)
+      return it->second;*/
 
-		auto end = descriptions.end();
+    auto end = descriptions.end();
 
-		// English tends to be a good fallback when the requested language isn't available
-		//if (language != DiscIO::IVolume::ELanguage::LANGUAGE_ENGLISH) {
-			auto it = descriptions.find(DiscIO::IVolume::ELanguage::LANGUAGE_ENGLISH);
-			if (it != end)
-				return it->second;
-		//}
+    // English tends to be a good fallback when the requested language isn't available
+    // if (language != DiscIO::IVolume::ELanguage::LANGUAGE_ENGLISH) {
+    auto it = descriptions.find(DiscIO::IVolume::ELanguage::LANGUAGE_ENGLISH);
+    if (it != end)
+      return it->second;
+    //}
 
-		// If English isn't available either, just pick something
-		if (!descriptions.empty())
-			return descriptions.cbegin()->second;
-	}
+    // If English isn't available either, just pick something
+    if (!descriptions.empty())
+      return descriptions.cbegin()->second;
+  }
 
-	return std::string();
+  return std::string();
 }
 
 static std::string GetGameId(std::string filename)
 {
-	__android_log_print(ANDROID_LOG_WARN, DOLPHIN_TAG, "Getting ID for file: %s", filename.c_str());
+  __android_log_print(ANDROID_LOG_WARN, DOLPHIN_TAG, "Getting ID for file: %s", filename.c_str());
 
-	std::unique_ptr<DiscIO::IVolume> volume(DiscIO::CreateVolumeFromFilename(filename));
-	if (volume == nullptr)
-		return std::string();
+  std::unique_ptr<DiscIO::IVolume> volume(DiscIO::CreateVolumeFromFilename(filename));
+  if (volume == nullptr)
+    return std::string();
 
-	std::string id = volume->GetUniqueID();
-	__android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Game ID: %s", id.c_str());
-	return id;
+  std::string id = volume->GetUniqueID();
+  __android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Game ID: %s", id.c_str());
+  return id;
 }
 
 static std::string GetCompany(std::string filename)
 {
-	__android_log_print(ANDROID_LOG_WARN, DOLPHIN_TAG, "Getting Company for file: %s", filename.c_str());
+  __android_log_print(ANDROID_LOG_WARN, DOLPHIN_TAG, "Getting Company for file: %s",
+                      filename.c_str());
 
-	std::unique_ptr<DiscIO::IVolume> volume(DiscIO::CreateVolumeFromFilename(filename));
-	if (volume == nullptr)
-		return std::string();
+  std::unique_ptr<DiscIO::IVolume> volume(DiscIO::CreateVolumeFromFilename(filename));
+  if (volume == nullptr)
+    return std::string();
 
-	std::string company = DiscIO::GetCompanyFromID(volume->GetMakerID());
-	__android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Company: %s", company.c_str());
-	return company;
+  std::string company = DiscIO::GetCompanyFromID(volume->GetMakerID());
+  __android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Company: %s", company.c_str());
+  return company;
 }
 
 static u64 GetFileSize(std::string filename)
 {
-	__android_log_print(ANDROID_LOG_WARN, DOLPHIN_TAG, "Getting size of file: %s", filename.c_str());
+  __android_log_print(ANDROID_LOG_WARN, DOLPHIN_TAG, "Getting size of file: %s", filename.c_str());
 
-	std::unique_ptr<DiscIO::IVolume> volume(DiscIO::CreateVolumeFromFilename(filename));
-	if (volume == nullptr)
-		return -1;
+  std::unique_ptr<DiscIO::IVolume> volume(DiscIO::CreateVolumeFromFilename(filename));
+  if (volume == nullptr)
+    return -1;
 
-	u64 size = volume->GetSize();
-	__android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Size: %" PRIu64, size);
-	return size;
+  u64 size = volume->GetSize();
+  __android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Size: %" PRIu64, size);
+  return size;
 }
 
-static std::string GetJString(JNIEnv *env, jstring jstr)
+static std::string GetJString(JNIEnv* env, jstring jstr)
 {
-	std::string result = "";
-	if (!jstr)
-		return result;
+  std::string result = "";
+  if (!jstr)
+    return result;
 
-	const char *s = env->GetStringUTFChars(jstr, nullptr);
-	result = s;
-	env->ReleaseStringUTFChars(jstr, s);
-	return result;
+  const char* s = env->GetStringUTFChars(jstr, nullptr);
+  result = s;
+  env->ReleaseStringUTFChars(jstr, s);
+  return result;
 }
 
 #ifdef __cplusplus
-extern "C"
-{
+extern "C" {
 #endif
 
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_UnPauseEmulation(JNIEnv *env, jobject obj);
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_PauseEmulation(JNIEnv *env, jobject obj);
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_StopEmulation(JNIEnv *env, jobject obj);
-JNIEXPORT jboolean JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_onGamePadEvent(JNIEnv *env, jobject obj, jstring jDevice, jint Button, jint Action);
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_onGamePadMoveEvent(JNIEnv *env, jobject obj, jstring jDevice, jint Axis, jfloat Value);
-JNIEXPORT jintArray JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetBanner(JNIEnv *env, jobject obj, jstring jFile);JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetTitle(JNIEnv *env, jobject obj, jstring jFilename);
-JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetDescription(JNIEnv *env, jobject obj, jstring jFilename);
-JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetGameId(JNIEnv *env, jobject obj, jstring jFilename);
-JNIEXPORT jint JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetCountry(JNIEnv *env, jobject obj, jstring jFilename);
-JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetCompany(JNIEnv *env, jobject obj, jstring jFilename);
-JNIEXPORT jlong JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetFilesize(JNIEnv *env, jobject obj, jstring jFilename);
-JNIEXPORT jint JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetPlatform(JNIEnv *env, jobject obj, jstring jFilename);
-JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetVersionString(JNIEnv *env, jobject obj);
-JNIEXPORT jboolean JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SupportsNEON(JNIEnv *env, jobject obj);
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SaveScreenShot(JNIEnv *env, jobject obj);
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_eglBindAPI(JNIEnv *env, jobject obj, jint api);
-JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetConfig(JNIEnv *env, jobject obj, jstring jFile, jstring jSection, jstring jKey, jstring jDefault);
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SetConfig(JNIEnv *env, jobject obj, jstring jFile, jstring jSection, jstring jKey, jstring jValue);
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SetFilename(JNIEnv *env, jobject obj, jstring jFile);
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SaveState(JNIEnv *env, jobject obj, jint slot);
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_LoadState(JNIEnv *env, jobject obj, jint slot);
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_CreateUserFolders(JNIEnv *env, jobject obj);
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SetUserDirectory(JNIEnv *env, jobject obj, jstring jDirectory);
-JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetUserDirectory(JNIEnv *env, jobject obj);
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SetProfiling(JNIEnv *env, jobject obj, jboolean enable);
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_WriteProfileResults(JNIEnv *env, jobject obj);
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_CacheClassesAndMethods(JNIEnv *env, jobject obj);
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_Run(JNIEnv *env, jobject obj);
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SurfaceChanged(JNIEnv *env, jobject obj, jobject _surf);
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SurfaceDestroyed(JNIEnv *env, jobject obj);
-
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_UnPauseEmulation(JNIEnv *env, jobject obj)
-{
-	std::lock_guard<std::mutex> guard(s_host_identity_lock);
-	Core::SetState(Core::CORE_RUN);
-}
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_PauseEmulation(JNIEnv *env, jobject obj)
-{
-	std::lock_guard<std::mutex> guard(s_host_identity_lock);
-	Core::SetState(Core::CORE_PAUSE);
-}
-
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_StopEmulation(JNIEnv *env, jobject obj)
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_UnPauseEmulation(JNIEnv* env,
+                                                                                     jobject obj);
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_PauseEmulation(JNIEnv* env,
+                                                                                   jobject obj);
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_StopEmulation(JNIEnv* env,
+                                                                                  jobject obj);
+JNIEXPORT jboolean JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_onGamePadEvent(
+    JNIEnv* env, jobject obj, jstring jDevice, jint Button, jint Action);
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_onGamePadMoveEvent(
+    JNIEnv* env, jobject obj, jstring jDevice, jint Axis, jfloat Value);
+JNIEXPORT jintArray JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetBanner(JNIEnv* env,
+                                                                                   jobject obj,
+                                                                                   jstring jFile);
+JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetTitle(JNIEnv* env,
+                                                                                jobject obj,
+                                                                                jstring jFilename);
+JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetDescription(
+    JNIEnv* env, jobject obj, jstring jFilename);
+JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetGameId(JNIEnv* env,
+                                                                                 jobject obj,
+                                                                                 jstring jFilename);
+JNIEXPORT jint JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetCountry(JNIEnv* env,
+                                                                               jobject obj,
+                                                                               jstring jFilename);
+JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetCompany(
+    JNIEnv* env, jobject obj, jstring jFilename);
+JNIEXPORT jlong JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetFilesize(JNIEnv* env,
+                                                                                 jobject obj,
+                                                                                 jstring jFilename);
+JNIEXPORT jint JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetPlatform(JNIEnv* env,
+                                                                                jobject obj,
+                                                                                jstring jFilename);
+JNIEXPORT jstring JNICALL
+Java_org_dolphinemu_dolphinemu_NativeLibrary_GetVersionString(JNIEnv* env, jobject obj);
+JNIEXPORT jboolean JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SupportsNEON(JNIEnv* env,
+                                                                                     jobject obj);
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SaveScreenShot(JNIEnv* env,
+                                                                                   jobject obj);
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_eglBindAPI(JNIEnv* env,
+                                                                               jobject obj,
+                                                                               jint api);
+JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetConfig(
+    JNIEnv* env, jobject obj, jstring jFile, jstring jSection, jstring jKey, jstring jDefault);
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SetConfig(
+    JNIEnv* env, jobject obj, jstring jFile, jstring jSection, jstring jKey, jstring jValue);
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SetFilename(JNIEnv* env,
+                                                                                jobject obj,
+                                                                                jstring jFile);
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SaveState(JNIEnv* env,
+                                                                              jobject obj,
+                                                                              jint slot);
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_LoadState(JNIEnv* env,
+                                                                              jobject obj,
+                                                                              jint slot);
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_CreateUserFolders(JNIEnv* env,
+                                                                                      jobject obj);
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SetUserDirectory(
+    JNIEnv* env, jobject obj, jstring jDirectory);
+JNIEXPORT jstring JNICALL
+Java_org_dolphinemu_dolphinemu_NativeLibrary_GetUserDirectory(JNIEnv* env, jobject obj);
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SetProfiling(JNIEnv* env,
+                                                                                 jobject obj,
+                                                                                 jboolean enable);
+JNIEXPORT void JNICALL
+Java_org_dolphinemu_dolphinemu_NativeLibrary_WriteProfileResults(JNIEnv* env, jobject obj);
+JNIEXPORT void JNICALL
+Java_org_dolphinemu_dolphinemu_NativeLibrary_CacheClassesAndMethods(JNIEnv* env, jobject obj);
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_Run(JNIEnv* env, jobject obj);
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SurfaceChanged(JNIEnv* env,
+                                                                                   jobject obj,
+                                                                                   jobject _surf);
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SurfaceDestroyed(JNIEnv* env,
+                                                                                     jobject obj);
+
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_UnPauseEmulation(JNIEnv* env,
+                                                                                     jobject obj)
+{
+  std::lock_guard<std::mutex> guard(s_host_identity_lock);
+  Core::SetState(Core::CORE_RUN);
+}
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_PauseEmulation(JNIEnv* env,
+                                                                                   jobject obj)
+{
+  std::lock_guard<std::mutex> guard(s_host_identity_lock);
+  Core::SetState(Core::CORE_PAUSE);
+}
+
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_StopEmulation(JNIEnv* env,
+                                                                                  jobject obj)
+{
+  std::lock_guard<std::mutex> guard(s_host_identity_lock);
+  Core::SaveScreenShot("thumb");
+  Renderer::s_screenshotCompleted.WaitFor(std::chrono::seconds(2));
+  Core::Stop();
+  updateMainFrameEvent.Set();  // Kick the waiting event
+}
+JNIEXPORT jboolean JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_onGamePadEvent(
+    JNIEnv* env, jobject obj, jstring jDevice, jint Button, jint Action)
+{
+  return ButtonManager::GamepadEvent(GetJString(env, jDevice), Button, Action);
+}
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_onGamePadMoveEvent(
+    JNIEnv* env, jobject obj, jstring jDevice, jint Axis, jfloat Value)
+{
+  ButtonManager::GamepadAxisEvent(GetJString(env, jDevice), Axis, Value);
+}
+
+JNIEXPORT jintArray JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetBanner(JNIEnv* env,
+                                                                                   jobject obj,
+                                                                                   jstring jFile)
 {
-	std::lock_guard<std::mutex> guard(s_host_identity_lock);
-	Core::SaveScreenShot("thumb");
-	Renderer::s_screenshotCompleted.WaitFor(std::chrono::seconds(2));
-	Core::Stop();
-	updateMainFrameEvent.Set(); // Kick the waiting event
-}
-JNIEXPORT jboolean JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_onGamePadEvent(JNIEnv *env, jobject obj, jstring jDevice, jint Button, jint Action)
-{
-	return ButtonManager::GamepadEvent(GetJString(env, jDevice), Button, Action);
-}
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_onGamePadMoveEvent(JNIEnv *env, jobject obj, jstring jDevice, jint Axis, jfloat Value)
-{
-	ButtonManager::GamepadAxisEvent(GetJString(env, jDevice), Axis, Value);
-}
+  std::string file = GetJString(env, jFile);
+  u32 uBanner[DVD_BANNER_WIDTH * DVD_BANNER_HEIGHT];
+  jintArray Banner = env->NewIntArray(DVD_BANNER_WIDTH * DVD_BANNER_HEIGHT);
 
-JNIEXPORT jintArray JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetBanner(JNIEnv *env, jobject obj, jstring jFile)
-{
-	std::string file = GetJString(env, jFile);
-	u32 uBanner[DVD_BANNER_WIDTH * DVD_BANNER_HEIGHT];
-	jintArray Banner = env->NewIntArray(DVD_BANNER_WIDTH * DVD_BANNER_HEIGHT);
-
-	if (LoadBanner(file, uBanner))
-	{
-		env->SetIntArrayRegion(Banner, 0, DVD_BANNER_WIDTH * DVD_BANNER_HEIGHT, (jint*)uBanner);
-	}
-	return Banner;
+  if (LoadBanner(file, uBanner))
+  {
+    env->SetIntArrayRegion(Banner, 0, DVD_BANNER_WIDTH * DVD_BANNER_HEIGHT, (jint*)uBanner);
+  }
+  return Banner;
 }
 
-JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetTitle(JNIEnv *env, jobject obj, jstring jFilename)
+JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetTitle(JNIEnv* env,
+                                                                                jobject obj,
+                                                                                jstring jFilename)
 {
-	std::string filename = GetJString(env, jFilename);
-	std::string name = GetTitle(filename);
-	return env->NewStringUTF(name.c_str());
+  std::string filename = GetJString(env, jFilename);
+  std::string name = GetTitle(filename);
+  return env->NewStringUTF(name.c_str());
 }
 
-JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetDescription(JNIEnv *env, jobject obj, jstring jFilename)
+JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetDescription(
+    JNIEnv* env, jobject obj, jstring jFilename)
 {
-	std::string filename = GetJString(env, jFilename);
-	std::string description = GetDescription(filename);
-	return env->NewStringUTF(description.c_str());
+  std::string filename = GetJString(env, jFilename);
+  std::string description = GetDescription(filename);
+  return env->NewStringUTF(description.c_str());
 }
 
-JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetGameId(JNIEnv *env, jobject obj, jstring jFilename)
+JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetGameId(JNIEnv* env,
+                                                                                 jobject obj,
+                                                                                 jstring jFilename)
 {
-	std::string filename = GetJString(env, jFilename);
-	std::string id = GetGameId(filename);
-	return env->NewStringUTF(id.c_str());
+  std::string filename = GetJString(env, jFilename);
+  std::string id = GetGameId(filename);
+  return env->NewStringUTF(id.c_str());
 }
 
-JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetCompany(JNIEnv *env, jobject obj, jstring jFilename)
+JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetCompany(JNIEnv* env,
+                                                                                  jobject obj,
+                                                                                  jstring jFilename)
 {
-	std::string filename = GetJString(env, jFilename);
-	std::string company = GetCompany(filename);
-	return env->NewStringUTF(company.c_str());
+  std::string filename = GetJString(env, jFilename);
+  std::string company = GetCompany(filename);
+  return env->NewStringUTF(company.c_str());
 }
 
-JNIEXPORT jint JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetCountry(JNIEnv *env, jobject obj, jstring jFilename)
+JNIEXPORT jint JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetCountry(JNIEnv* env,
+                                                                               jobject obj,
+                                                                               jstring jFilename)
 {
-	std::string filename = GetJString(env, jFilename);
-	int country = GetCountry(filename);
-	return country;
+  std::string filename = GetJString(env, jFilename);
+  int country = GetCountry(filename);
+  return country;
 }
 
-JNIEXPORT jlong JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetFilesize(JNIEnv *env, jobject obj, jstring jFilename)
+JNIEXPORT jlong JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetFilesize(JNIEnv* env,
+                                                                                 jobject obj,
+                                                                                 jstring jFilename)
 {
-	std::string filename = GetJString(env, jFilename);
-	u64 size = GetFileSize(filename);
-	return size;
+  std::string filename = GetJString(env, jFilename);
+  u64 size = GetFileSize(filename);
+  return size;
 }
 
-JNIEXPORT jint JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetPlatform(JNIEnv *env, jobject obj, jstring jFilename)
+JNIEXPORT jint JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetPlatform(JNIEnv* env,
+                                                                                jobject obj,
+                                                                                jstring jFilename)
 {
-	std::string filename = GetJString(env, jFilename);
-	int platform = GetPlatform(filename);
-	return platform;
+  std::string filename = GetJString(env, jFilename);
+  int platform = GetPlatform(filename);
+  return platform;
 }
 
-JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetVersionString(JNIEnv *env, jobject obj)
+JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetVersionString(JNIEnv* env,
+                                                                                        jobject obj)
 {
-	return env->NewStringUTF(scm_rev_str.c_str());
+  return env->NewStringUTF(scm_rev_str.c_str());
 }
 
-JNIEXPORT jboolean JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SupportsNEON(JNIEnv *env, jobject obj)
+JNIEXPORT jboolean JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SupportsNEON(JNIEnv* env,
+                                                                                     jobject obj)
 {
-	return cpu_info.bASIMD;
+  return cpu_info.bASIMD;
 }
 
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SaveScreenShot(JNIEnv *env, jobject obj)
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SaveScreenShot(JNIEnv* env,
+                                                                                   jobject obj)
 {
-	std::lock_guard<std::mutex> guard(s_host_identity_lock);
-	Core::SaveScreenShot();
+  std::lock_guard<std::mutex> guard(s_host_identity_lock);
+  Core::SaveScreenShot();
 }
 
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_eglBindAPI(JNIEnv *env, jobject obj, jint api)
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_eglBindAPI(JNIEnv* env,
+                                                                               jobject obj,
+                                                                               jint api)
 {
-	eglBindAPI(api);
+  eglBindAPI(api);
 }
 
-JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetConfig(JNIEnv *env, jobject obj, jstring jFile, jstring jSection, jstring jKey, jstring jDefault)
+JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetConfig(
+    JNIEnv* env, jobject obj, jstring jFile, jstring jSection, jstring jKey, jstring jDefault)
 {
-	IniFile ini;
-	std::string file         = GetJString(env, jFile);
-	std::string section      = GetJString(env, jSection);
-	std::string key          = GetJString(env, jKey);
-	std::string defaultValue = GetJString(env, jDefault);
+  IniFile ini;
+  std::string file = GetJString(env, jFile);
+  std::string section = GetJString(env, jSection);
+  std::string key = GetJString(env, jKey);
+  std::string defaultValue = GetJString(env, jDefault);
 
-	ini.Load(File::GetUserPath(D_CONFIG_IDX) + std::string(file));
-	std::string value;
+  ini.Load(File::GetUserPath(D_CONFIG_IDX) + std::string(file));
+  std::string value;
 
-	ini.GetOrCreateSection(section)->Get(key, &value, defaultValue);
+  ini.GetOrCreateSection(section)->Get(key, &value, defaultValue);
 
-	return env->NewStringUTF(value.c_str());
+  return env->NewStringUTF(value.c_str());
 }
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SetConfig(JNIEnv *env, jobject obj, jstring jFile, jstring jSection, jstring jKey, jstring jValue)
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SetConfig(
+    JNIEnv* env, jobject obj, jstring jFile, jstring jSection, jstring jKey, jstring jValue)
 {
-	IniFile ini;
-	std::string file         = GetJString(env, jFile);
-	std::string section      = GetJString(env, jSection);
-	std::string key          = GetJString(env, jKey);
-	std::string value        = GetJString(env, jValue);
+  IniFile ini;
+  std::string file = GetJString(env, jFile);
+  std::string section = GetJString(env, jSection);
+  std::string key = GetJString(env, jKey);
+  std::string value = GetJString(env, jValue);
 
-	ini.Load(File::GetUserPath(D_CONFIG_IDX) + std::string(file));
+  ini.Load(File::GetUserPath(D_CONFIG_IDX) + std::string(file));
 
-	ini.GetOrCreateSection(section)->Set(key, value);
-	ini.Save(File::GetUserPath(D_CONFIG_IDX) + std::string(file));
+  ini.GetOrCreateSection(section)->Set(key, value);
+  ini.Save(File::GetUserPath(D_CONFIG_IDX) + std::string(file));
 }
 
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SetFilename(JNIEnv *env, jobject obj, jstring jFile)
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SetFilename(JNIEnv* env,
+                                                                                jobject obj,
+                                                                                jstring jFile)
 {
-	g_filename = GetJString(env, jFile);
+  g_filename = GetJString(env, jFile);
 }
 
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SaveState(JNIEnv *env, jobject obj, jint slot)
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SaveState(JNIEnv* env,
+                                                                              jobject obj,
+                                                                              jint slot)
 {
-	std::lock_guard<std::mutex> guard(s_host_identity_lock);
-	State::Save(slot);
+  std::lock_guard<std::mutex> guard(s_host_identity_lock);
+  State::Save(slot);
 }
 
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_LoadState(JNIEnv *env, jobject obj, jint slot)
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_LoadState(JNIEnv* env,
+                                                                              jobject obj,
+                                                                              jint slot)
 {
-	std::lock_guard<std::mutex> guard(s_host_identity_lock);
-	State::Load(slot);
+  std::lock_guard<std::mutex> guard(s_host_identity_lock);
+  State::Load(slot);
 }
 
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_CreateUserFolders(JNIEnv *env, jobject obj)
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_CreateUserFolders(JNIEnv* env,
+                                                                                      jobject obj)
 {
-	File::CreateFullPath(File::GetUserPath(D_CONFIG_IDX));
-	File::CreateFullPath(File::GetUserPath(D_GCUSER_IDX));
-	File::CreateFullPath(File::GetUserPath(D_WIIROOT_IDX) + DIR_SEP WII_WC24CONF_DIR DIR_SEP "mbox" DIR_SEP);
-	File::CreateFullPath(File::GetUserPath(D_WIIROOT_IDX) + DIR_SEP "shared2" DIR_SEP "succession" DIR_SEP);
-	File::CreateFullPath(File::GetUserPath(D_WIIROOT_IDX) + DIR_SEP "shared2" DIR_SEP "ec" DIR_SEP);
-	File::CreateFullPath(File::GetUserPath(D_WIIROOT_IDX) + DIR_SEP WII_SYSCONF_DIR DIR_SEP);
-	File::CreateFullPath(File::GetUserPath(D_CACHE_IDX));
-	File::CreateFullPath(File::GetUserPath(D_DUMPDSP_IDX));
-	File::CreateFullPath(File::GetUserPath(D_DUMPTEXTURES_IDX));
-	File::CreateFullPath(File::GetUserPath(D_HIRESTEXTURES_IDX));
-	File::CreateFullPath(File::GetUserPath(D_SCREENSHOTS_IDX));
-	File::CreateFullPath(File::GetUserPath(D_STATESAVES_IDX));
-	File::CreateFullPath(File::GetUserPath(D_MAILLOGS_IDX));
-	File::CreateFullPath(File::GetUserPath(D_SHADERS_IDX) + "Anaglyph" DIR_SEP);
-	File::CreateFullPath(File::GetUserPath(D_GCUSER_IDX) + USA_DIR DIR_SEP);
-	File::CreateFullPath(File::GetUserPath(D_GCUSER_IDX) + EUR_DIR DIR_SEP);
-	File::CreateFullPath(File::GetUserPath(D_GCUSER_IDX) + JAP_DIR DIR_SEP);
+  File::CreateFullPath(File::GetUserPath(D_CONFIG_IDX));
+  File::CreateFullPath(File::GetUserPath(D_GCUSER_IDX));
+  File::CreateFullPath(File::GetUserPath(D_WIIROOT_IDX) + DIR_SEP WII_WC24CONF_DIR DIR_SEP
+                       "mbox" DIR_SEP);
+  File::CreateFullPath(File::GetUserPath(D_WIIROOT_IDX) + DIR_SEP "shared2" DIR_SEP
+                                                                  "succession" DIR_SEP);
+  File::CreateFullPath(File::GetUserPath(D_WIIROOT_IDX) + DIR_SEP "shared2" DIR_SEP "ec" DIR_SEP);
+  File::CreateFullPath(File::GetUserPath(D_WIIROOT_IDX) + DIR_SEP WII_SYSCONF_DIR DIR_SEP);
+  File::CreateFullPath(File::GetUserPath(D_CACHE_IDX));
+  File::CreateFullPath(File::GetUserPath(D_DUMPDSP_IDX));
+  File::CreateFullPath(File::GetUserPath(D_DUMPTEXTURES_IDX));
+  File::CreateFullPath(File::GetUserPath(D_HIRESTEXTURES_IDX));
+  File::CreateFullPath(File::GetUserPath(D_SCREENSHOTS_IDX));
+  File::CreateFullPath(File::GetUserPath(D_STATESAVES_IDX));
+  File::CreateFullPath(File::GetUserPath(D_MAILLOGS_IDX));
+  File::CreateFullPath(File::GetUserPath(D_SHADERS_IDX) + "Anaglyph" DIR_SEP);
+  File::CreateFullPath(File::GetUserPath(D_GCUSER_IDX) + USA_DIR DIR_SEP);
+  File::CreateFullPath(File::GetUserPath(D_GCUSER_IDX) + EUR_DIR DIR_SEP);
+  File::CreateFullPath(File::GetUserPath(D_GCUSER_IDX) + JAP_DIR DIR_SEP);
 }
 
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SetUserDirectory(JNIEnv *env, jobject obj, jstring jDirectory)
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SetUserDirectory(
+    JNIEnv* env, jobject obj, jstring jDirectory)
 {
-	std::lock_guard<std::mutex> guard(s_host_identity_lock);
-	std::string directory = GetJString(env, jDirectory);
-	g_set_userpath = directory;
-	UICommon::SetUserDirectory(directory);
+  std::lock_guard<std::mutex> guard(s_host_identity_lock);
+  std::string directory = GetJString(env, jDirectory);
+  g_set_userpath = directory;
+  UICommon::SetUserDirectory(directory);
 }
 
-JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetUserDirectory(JNIEnv *env, jobject obj)
+JNIEXPORT jstring JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_GetUserDirectory(JNIEnv* env,
+                                                                                        jobject obj)
 {
-	return env->NewStringUTF(File::GetUserPath(D_USER_IDX).c_str());
+  return env->NewStringUTF(File::GetUserPath(D_USER_IDX).c_str());
 }
 
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SetProfiling(JNIEnv *env, jobject obj, jboolean enable)
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SetProfiling(JNIEnv* env,
+                                                                                 jobject obj,
+                                                                                 jboolean enable)
 {
-	std::lock_guard<std::mutex> guard(s_host_identity_lock);
-	Core::SetState(Core::CORE_PAUSE);
-	JitInterface::ClearCache();
-	Profiler::g_ProfileBlocks = enable;
-	Core::SetState(Core::CORE_RUN);
+  std::lock_guard<std::mutex> guard(s_host_identity_lock);
+  Core::SetState(Core::CORE_PAUSE);
+  JitInterface::ClearCache();
+  Profiler::g_ProfileBlocks = enable;
+  Core::SetState(Core::CORE_RUN);
 }
 
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_WriteProfileResults(JNIEnv *env, jobject obj)
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_WriteProfileResults(JNIEnv* env,
+                                                                                        jobject obj)
 {
-	std::lock_guard<std::mutex> guard(s_host_identity_lock);
-	std::string filename = File::GetUserPath(D_DUMP_IDX) + "Debug/profiler.txt";
-	File::CreateFullPath(filename);
-	JitInterface::WriteProfileResults(filename);
+  std::lock_guard<std::mutex> guard(s_host_identity_lock);
+  std::string filename = File::GetUserPath(D_DUMP_IDX) + "Debug/profiler.txt";
+  File::CreateFullPath(filename);
+  JitInterface::WriteProfileResults(filename);
 }
 
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_CacheClassesAndMethods(JNIEnv *env, jobject obj)
+JNIEXPORT void JNICALL
+Java_org_dolphinemu_dolphinemu_NativeLibrary_CacheClassesAndMethods(JNIEnv* env, jobject obj)
 {
-	// This class reference is only valid for the lifetime of this method.
-	jclass localClass = env->FindClass("org/dolphinemu/dolphinemu/NativeLibrary");
+  // This class reference is only valid for the lifetime of this method.
+  jclass localClass = env->FindClass("org/dolphinemu/dolphinemu/NativeLibrary");
 
-	// This reference, however, is valid until we delete it.
-	g_jni_class = reinterpret_cast<jclass>(env->NewGlobalRef(localClass));
+  // This reference, however, is valid until we delete it.
+  g_jni_class = reinterpret_cast<jclass>(env->NewGlobalRef(localClass));
 
-	// TODO Find a place for this.
-	// So we don't leak a reference to NativeLibrary.class.
-	// env->DeleteGlobalRef(g_jni_class);
+  // TODO Find a place for this.
+  // So we don't leak a reference to NativeLibrary.class.
+  // env->DeleteGlobalRef(g_jni_class);
 
-	// Method signature taken from javap -s Source/Android/app/build/intermediates/classes/arm/debug/org/dolphinemu/dolphinemu/NativeLibrary.class
-	g_jni_method_alert = env->GetStaticMethodID(g_jni_class, "displayAlertMsg", "(Ljava/lang/String;)V");
-	g_jni_method_end = env->GetStaticMethodID(g_jni_class, "endEmulationActivity", "()V");
+  // Method signature taken from javap -s
+  // Source/Android/app/build/intermediates/classes/arm/debug/org/dolphinemu/dolphinemu/NativeLibrary.class
+  g_jni_method_alert =
+      env->GetStaticMethodID(g_jni_class, "displayAlertMsg", "(Ljava/lang/String;)V");
+  g_jni_method_end = env->GetStaticMethodID(g_jni_class, "endEmulationActivity", "()V");
 }
 
 // Surface Handling
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SurfaceChanged(JNIEnv *env, jobject obj, jobject _surf)
-{
-	surf = ANativeWindow_fromSurface(env, _surf);
-	if (surf == nullptr)
-		__android_log_print(ANDROID_LOG_ERROR, DOLPHIN_TAG, "Error: Surface is null.");
-
-	// If GLInterface isn't a thing yet then we don't need to let it know that the surface has changed
-	if (GLInterface)
-	{
-		GLInterface->UpdateHandle(surf);
-		Renderer::s_ChangedSurface.Reset();
-		Renderer::s_SurfaceNeedsChanged.Set();
-		Renderer::s_ChangedSurface.Wait();
-	}
-}
-
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SurfaceDestroyed(JNIEnv *env, jobject obj)
-{
-	if (surf)
-	{
-		ANativeWindow_release(surf);
-		surf = nullptr;
-	}
-
-	// If GLInterface isn't a thing yet then we don't need to let it know that the surface has changed
-	if (GLInterface)
-	{
-		GLInterface->UpdateHandle(nullptr);
-		Renderer::s_ChangedSurface.Reset();
-		Renderer::s_SurfaceNeedsChanged.Set();
-		Renderer::s_ChangedSurface.Wait();
-	}
-}
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_RefreshWiimotes(JNIEnv *env, jobject obj)
-{
-	std::lock_guard<std::mutex> guard(s_host_identity_lock);
-	WiimoteReal::Refresh();
-}
-
-JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_Run(JNIEnv *env, jobject obj)
-{
-	__android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Running : %s", g_filename.c_str());
-
-	// Install our callbacks
-	OSD::AddCallback(OSD::CallbackType::Initialization, ButtonManager::Init);
-	OSD::AddCallback(OSD::CallbackType::Shutdown, ButtonManager::Shutdown);
-
-	RegisterMsgAlertHandler(&MsgAlert);
-
-	std::unique_lock<std::mutex> guard(s_host_identity_lock);
-	UICommon::SetUserDirectory(g_set_userpath);
-	UICommon::Init();
-
-	WiimoteReal::InitAdapterClass();
-
-	// No use running the loop when booting fails
-	s_have_wm_user_stop = false;
-	if ( BootManager::BootCore( g_filename.c_str() ) )
-	{
-		static constexpr int TIMEOUT   = 10000;
-		static constexpr int WAIT_STEP = 25;
-		int time_waited = 0;
-		// A Core::CORE_ERROR state would be helpful here.
-		while (!Core::IsRunning() && time_waited < TIMEOUT && !s_have_wm_user_stop)
-		{
-			std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_STEP));
-			time_waited += WAIT_STEP;
-		}
-		while (Core::IsRunning())
-		{
-			guard.unlock();
-			updateMainFrameEvent.Wait();
-			guard.lock();
-			Core::HostDispatchJobs();
-		}
-	}
-
-	Core::Shutdown();
-	UICommon::Shutdown();
-	guard.unlock();
-
-	if (surf)
-	{
-		ANativeWindow_release(surf);
-		surf = nullptr;
-	}
-
-	// Execute the Java method.
-	env->CallStaticVoidMethod(g_jni_class, g_jni_method_end);
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SurfaceChanged(JNIEnv* env,
+                                                                                   jobject obj,
+                                                                                   jobject _surf)
+{
+  surf = ANativeWindow_fromSurface(env, _surf);
+  if (surf == nullptr)
+    __android_log_print(ANDROID_LOG_ERROR, DOLPHIN_TAG, "Error: Surface is null.");
+
+  // If GLInterface isn't a thing yet then we don't need to let it know that the surface has changed
+  if (GLInterface)
+  {
+    GLInterface->UpdateHandle(surf);
+    Renderer::s_ChangedSurface.Reset();
+    Renderer::s_SurfaceNeedsChanged.Set();
+    Renderer::s_ChangedSurface.Wait();
+  }
+}
+
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_SurfaceDestroyed(JNIEnv* env,
+                                                                                     jobject obj)
+{
+  if (surf)
+  {
+    ANativeWindow_release(surf);
+    surf = nullptr;
+  }
+
+  // If GLInterface isn't a thing yet then we don't need to let it know that the surface has changed
+  if (GLInterface)
+  {
+    GLInterface->UpdateHandle(nullptr);
+    Renderer::s_ChangedSurface.Reset();
+    Renderer::s_SurfaceNeedsChanged.Set();
+    Renderer::s_ChangedSurface.Wait();
+  }
+}
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_RefreshWiimotes(JNIEnv* env,
+                                                                                    jobject obj)
+{
+  std::lock_guard<std::mutex> guard(s_host_identity_lock);
+  WiimoteReal::Refresh();
+}
+
+JNIEXPORT void JNICALL Java_org_dolphinemu_dolphinemu_NativeLibrary_Run(JNIEnv* env, jobject obj)
+{
+  __android_log_print(ANDROID_LOG_INFO, DOLPHIN_TAG, "Running : %s", g_filename.c_str());
+
+  // Install our callbacks
+  OSD::AddCallback(OSD::CallbackType::Initialization, ButtonManager::Init);
+  OSD::AddCallback(OSD::CallbackType::Shutdown, ButtonManager::Shutdown);
+
+  RegisterMsgAlertHandler(&MsgAlert);
+
+  std::unique_lock<std::mutex> guard(s_host_identity_lock);
+  UICommon::SetUserDirectory(g_set_userpath);
+  UICommon::Init();
+
+  WiimoteReal::InitAdapterClass();
+
+  // No use running the loop when booting fails
+  s_have_wm_user_stop = false;
+  if (BootManager::BootCore(g_filename.c_str()))
+  {
+    static constexpr int TIMEOUT = 10000;
+    static constexpr int WAIT_STEP = 25;
+    int time_waited = 0;
+    // A Core::CORE_ERROR state would be helpful here.
+    while (!Core::IsRunning() && time_waited < TIMEOUT && !s_have_wm_user_stop)
+    {
+      std::this_thread::sleep_for(std::chrono::milliseconds(WAIT_STEP));
+      time_waited += WAIT_STEP;
+    }
+    while (Core::IsRunning())
+    {
+      guard.unlock();
+      updateMainFrameEvent.Wait();
+      guard.lock();
+      Core::HostDispatchJobs();
+    }
+  }
+
+  Core::Shutdown();
+  UICommon::Shutdown();
+  guard.unlock();
+
+  if (surf)
+  {
+    ANativeWindow_release(surf);
+    surf = nullptr;
+  }
+
+  // Execute the Java method.
+  env->CallStaticVoidMethod(g_jni_class, g_jni_method_end);
 }
 
-
 #ifdef __cplusplus
 }
 #endif