Merge pull request #22451 from hrydgard/android-egl-replace-javagl

Android: Replace JavaGL init with EGL

Author: hrydgard

CMakeLists.txt

@@ -925,6 +925,8 @@ if(ANDROID)
 		android/jni/app-android.cpp
 		android/jni/AndroidAudio.cpp
 		android/jni/AndroidAudio.h
+		android/jni/AndroidEGLGraphicsContext.cpp
+		android/jni/AndroidEGLGraphicsContext.h
 		android/jni/OpenSLContext.cpp
 		android/jni/OpenSLContext.h
 	)

Common/GPU/GraphicsContext.h

@@ -54,10 +54,6 @@ class GraphicsContext {
 	// Called from the emu thread, so be ready for that.
 	virtual void NotifyEmuThreadExit() {}
 
-	// The API context that queued-up commands were recorded against is gone (or isn't current on the
-	// thread about to drain them), so they must not be executed for real. Only meaningful on Android GL.
-	virtual void NotifyContextLost() {}
-
 	// Useful for checks that need to be performed every frame.
 	// Should strive to get rid of these.
 	virtual void Poll() {}

Common/GPU/OpenGL/OpenGLGraphicsContext.h

@@ -33,19 +33,15 @@ class OpenGLGraphicsContext : public GraphicsContext {
 		renderManager_->ThreadEnd();
 	}
 
-	void NotifyContextLost() override {
-		if (renderManager_) {
-			renderManager_->SetSkipGLCalls();
-		}
-	}
-
 	// Call from emu thread
 	void NotifyEmuThreadExit() override {
 		renderManager_->SetSkipGLCalls();
 		renderManager_->NotifyEmuThreadExit();
 	}
 
-private:
+protected:
+	// Protected rather than private so a subclass that owns the real context (see
+	// android/jni/AndroidEGLGraphicsContext.h) can hook up a swap function.
 	Draw::DrawContext *draw_ = nullptr;
 	GLRenderManager *renderManager_ = nullptr;
 };

Common/GPU/Vulkan/VulkanQueueRunner.cpp

@@ -8,7 +8,7 @@
 
 using namespace PPSSPP_VK;
 
-// Debug help: adb logcat -s DEBUG AndroidRuntime PPSSPPNativeActivity PPSSPP NativeGLView NativeRenderer NativeSurfaceView PowerSaveModeReceiver InputDeviceState PpssppActivity CameraHelper PPSSPPSizeManager
+// Debug help: adb logcat -s DEBUG AndroidRuntime PPSSPPNativeActivity PPSSPP NativeSurfaceView PowerSaveModeReceiver InputDeviceState PpssppActivity CameraHelper PPSSPPSizeManager
 
 static void MergeRenderAreaRectInto(VkRect2D *dest, const VkRect2D &src) {
 	if (dest->offset.x > src.offset.x) {

Core/EmuThread.cpp

@@ -13,7 +13,10 @@
 #include "Common/Log.h"
 #include "Common/StringUtils.h"
 #include "Common/GPU/GraphicsContext.h"
+#include "Common/System/Display.h"
 #include "Common/Thread/ThreadUtil.h"
+#include "Common/TimeUtil.h"
+#include "Common/VR/PPSSPPVR.h"
 
 #include "Core/EmuThread.h"
 #include "Core/Core.h"
@@ -125,34 +128,68 @@ bool RunMainLoop(GraphicsContext *graphicsContext, Application *application, std
 	return true;
 }
 
-// Call InitAPI and ShutdownAPI outside this!
-bool MainThreadFunc(GraphicsContext *graphicsContext, Application *application, const WindowDesc &windowDesc, std::function<bool(GraphicsContext *)> frame, std::string *errorMessage) {
-	// This is now the render thread, and will spawn the emu thread below.
-	if (!graphicsContext->InitSurface(windowDesc.winsys, windowDesc.data1, windowDesc.data2, errorMessage)) {
-		ERROR_LOG(Log::G3D, "MainThreadFunc: InitSurface failed: %s", errorMessage->c_str());
-		delete application;
-		return false;
+void RunGraphicsLoop(GraphicsContext *graphicsContext, Application *application, std::function<bool(GraphicsContext *)> frame, std::function<bool()> shouldExit) {
+	if (!graphicsContext->NeedsSeparateEmuThread()) {
+		// The backend spawns its own render thread, so this thread is simply where emulation runs.
+		SetCurrentThreadName("EmuThread");
+		RunMainLoop(graphicsContext, application, frame);
+		return;
 	}
-	if (graphicsContext->NeedsSeparateEmuThread()) {
-		SetCurrentThreadName("RenderThread");
 
-		g_inLoop = true;
-		std::thread emuThread = EmuThread_Start(graphicsContext, application, frame);
-		graphicsContext->ThreadStart();
-		// This thread becomes the render thread. EmuThread will tell it when to quit by sending a message.
-		while (graphicsContext->ThreadFrame()) {}
-		EmuThread_Join(graphicsContext, emuThread);
-		g_inLoop = false;
+	// OpenGL wants its API calls on the thread its context is current on, which is this one. So
+	// this thread becomes the render thread - all it does is execute the GPU commands the emu
+	// thread queues up - and emulation moves to a thread we spawn here.
+	SetCurrentThreadName("RenderThread");
 
-		graphicsContext->ThreadEnd();
+	g_inLoop = true;
 
-		INFO_LOG(Log::System, "RenderThread - joined");
+	// EmuThread_Start calls ThreadStart() for us, and EmuThread_Join calls ThreadEnd(), so neither
+	// is called directly here.
+	std::thread emuThread = EmuThread_Start(graphicsContext, application, frame);
 
-	} else {
-		SetCurrentThreadName("MainThread");
+	if (IsVREnabled()) {
+		static bool vrFirstStart = true;
+		EnterVR(vrFirstStart);
+		vrFirstStart = false;
+	}
 
-		RunMainLoop(graphicsContext, application, frame);
+	// Normally ThreadFrame() returning false is what gets us out of here - the frame callback
+	// decides emulation is done, and the emu thread's NotifyEmuThreadExit then queues the exit.
+	// That isn't enough in VR: while the session is idle we skip ThreadFrame() entirely, and going
+	// to the background is precisely when the session goes idle, so the exit would never be seen
+	// and whoever is waiting to join this thread would wait forever. Hence shouldExit.
+	while (!(shouldExit && shouldExit())) {
+		if (IsVREnabled() && !StartVRRender()) {
+			// The session isn't active, so there's no frame to render into. Nothing to do until it
+			// comes back - wait out a frame rather than spinning on it.
+			sleep_ms(16, "vr-session-idle");
+			continue;
+		}
+		if (!graphicsContext->ThreadFrame()) {
+			break;
+		}
+		if (IsVREnabled()) {
+			UpdateVRInput(g_Config.bHapticFeedback, g_display.dpi_scale_x, g_display.dpi_scale_y);
+			FinishVRRender();
+		}
+	}
+
+	// Also drains whatever the emu thread still had queued, so it can't get stuck waiting on us.
+	EmuThread_Join(graphicsContext, emuThread);
+
+	g_inLoop = false;
+
+	INFO_LOG(Log::System, "RenderThread - joined");
+}
+
+// Call InitAPI and ShutdownAPI outside this!
+bool MainThreadFunc(GraphicsContext *graphicsContext, Application *application, const WindowDesc &windowDesc, std::function<bool(GraphicsContext *)> frame, std::string *errorMessage) {
+	if (!graphicsContext->InitSurface(windowDesc.winsys, windowDesc.data1, windowDesc.data2, errorMessage)) {
+		ERROR_LOG(Log::G3D, "MainThreadFunc: InitSurface failed: %s", errorMessage->c_str());
+		delete application;
+		return false;
 	}
+	RunGraphicsLoop(graphicsContext, application, frame);
 	graphicsContext->ShutdownSurface();
 	return true;
 }

Core/EmuThread.h

@@ -50,3 +50,15 @@ void EmuThread_Join(GraphicsContext *graphicsContext, std::thread &emuThread);
 // Call from the main thread.
 // NOTE: Does take ownership over Application (which is just a wrapper for NativeInitGraphics/NativeShutdownGraphics/NativeFrame).
 bool RunMainLoop(GraphicsContext *graphicsContext, Application *application, std::function<bool(GraphicsContext *)> frame);
+
+// Runs whichever thread arrangement graphicsContext asks for, on the calling thread, and doesn't
+// return until the emu thread is done. Either this thread becomes the render thread and the emu
+// thread is spawned alongside it (OpenGL, which needs its API calls on the thread its context is
+// current on), or this thread just runs the main loop because the backend spawns its own render
+// thread (Vulkan, D3D11).
+// The surface has to be initialized already, and is left alone - use MainThreadFunc if you want
+// that taken care of too.
+// shouldExit is optional, but required if you might run this in VR: see the comment on the render
+// loop in EmuThread.cpp for why ThreadFrame() alone isn't enough to get out of there.
+// NOTE: Does take ownership over Application (which is just a wrapper for NativeInitGraphics/NativeShutdownGraphics/NativeFrame).
+void RunGraphicsLoop(GraphicsContext *graphicsContext, Application *application, std::function<bool(GraphicsContext *)> frame, std::function<bool()> shouldExit = nullptr);

android/jni/Android.mk

@@ -940,6 +940,7 @@ LOCAL_MODULE := ppsspp_jni
 LOCAL_SRC_FILES := \
   $(SRC)/android/jni/app-android.cpp \
   $(SRC)/android/jni/AndroidAudio.cpp \
+  $(SRC)/android/jni/AndroidEGLGraphicsContext.cpp \
   $(SRC)/android/jni/OpenSLContext.cpp \
   $(SRC)/UI/ImDebugger/ImDebugger.cpp \
   $(SRC)/UI/ImDebugger/ImGe.cpp \