X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=plugins%2Fgpulib%2Fgpulib_thread_if.c;h=1583783d4549fa44aa8d2c15a7eb7ca5a256c4ee;hb=d0d2939d7a485bbe97017e5ae20b504d225c09d3;hp=f0f607d621cbfb12411b39eb839c04f7341ac99d;hpb=c765eb86debdc06fe304511bc2edbb6f3e3d7813;p=pcsx_rearmed.git

diff --git a/plugins/gpulib/gpulib_thread_if.c b/plugins/gpulib/gpulib_thread_if.c
index f0f607d6..1583783d 100644
--- a/plugins/gpulib/gpulib_thread_if.c
+++ b/plugins/gpulib/gpulib_thread_if.c
@@ -18,12 +18,17 @@
 ***************************************************************************/
 
 #include <stdlib.h>
+#include <stdio.h>
 #include <string.h>
 #include <pthread.h>
 #include "../gpulib/gpu.h"
 #include "../../frontend/plugin_lib.h"
 #include "gpulib_thread_if.h"
 
+#define FALSE 0
+#define TRUE 1
+#define BOOL unsigned short
+
 typedef struct {
 	uint32_t *cmd_list;
 	int count;
@@ -47,14 +52,15 @@ typedef struct {
 	pthread_cond_t cond_queue_empty;
 	video_thread_queue *queue;
 	video_thread_queue *bg_queue;
-	bool running;
+	BOOL running;
 } video_thread_state;
 
 static video_thread_state thread;
 static video_thread_queue queues[2];
 static int thread_rendering;
-static bool hold_cmds;
-static bool needs_display;
+static BOOL hold_cmds;
+static BOOL needs_display;
+static BOOL flushed;
 
 extern const unsigned char cmd_lengths[];
 
@@ -62,7 +68,10 @@ static void *video_thread_main(void *arg) {
 	video_thread_state *thread = (video_thread_state *)arg;
 	video_thread_cmd *cmd;
 	int i;
+
+#ifdef _3DS
 	static int processed = 0;
+#endif /* _3DS */
 
 	while(1) {
 		int result, last_cmd, start, end;
@@ -99,7 +108,7 @@ static void *video_thread_main(void *arg) {
 				svcSleepThread(1);
 				processed %= 512;
 			}
-#endif
+#endif /* _3DS */
 		}
 
 		pthread_mutex_lock(&thread->queue_lock);
@@ -124,7 +133,6 @@ static void cmd_queue_swap() {
 		tmp = thread.queue;
 		thread.queue = thread.bg_queue;
 		thread.bg_queue = tmp;
-		needs_display = true;
 		pthread_cond_signal(&thread.cond_msg_avail);
 	}
 	pthread_mutex_unlock(&thread.queue_lock);
@@ -160,6 +168,13 @@ void renderer_sync(void) {
 		return;
 	}
 
+	if (thread.bg_queue->used) {
+		/* When we flush the background queue, the vblank handler can't
+		 * know that we had a frame pending, and we delay rendering too
+		 * long. Force it. */
+		flushed = TRUE;
+	}
+
 	/* Flush both queues. This is necessary because gpulib could be
 	 * trying to process a DMA write that a command in the queue should
 	 * run beforehand. For example, Xenogears sprites write a black
@@ -169,7 +184,7 @@ void renderer_sync(void) {
 	 * drop a frame. */
 	renderer_wait();
 	cmd_queue_swap();
-	hold_cmds = false;
+	hold_cmds = FALSE;
 	renderer_wait();
 }
 
@@ -178,7 +193,7 @@ static void video_thread_stop() {
 	renderer_sync();
 
 	if (thread.running) {
-		thread.running = false;
+		thread.running = FALSE;
 		pthread_cond_signal(&thread.cond_msg_avail);
 		pthread_join(thread.thread, NULL);
 	}
@@ -215,7 +230,7 @@ static void video_thread_start() {
 	thread.queue = &queues[0];
 	thread.bg_queue = &queues[1];
 
-	thread.running = true;
+	thread.running = TRUE;
 	return;
 
  error:
@@ -227,7 +242,7 @@ static void video_thread_queue_cmd(uint32_t *list, int count, int last_cmd) {
 	video_thread_cmd *cmd;
 	uint32_t *cmd_list;
 	video_thread_queue *queue;
-	bool lock;
+	BOOL lock;
 
 	cmd_list = (uint32_t *)calloc(count, sizeof(uint32_t));
 
@@ -248,10 +263,10 @@ static void video_thread_queue_cmd(uint32_t *list, int count, int last_cmd) {
 
 	if (hold_cmds) {
 		queue = thread.bg_queue;
-		lock = false;
+		lock = FALSE;
 	} else {
 		queue = thread.queue;
-		lock = true;
+		lock = TRUE;
 	}
 
 	if (lock) {
@@ -425,7 +440,7 @@ void renderer_notify_update_lace(int updated) {
 	}
 
 	pthread_mutex_lock(&thread.queue_lock);
-	if (thread.bg_queue->used) {
+	if (thread.bg_queue->used || flushed) {
 		/* We have commands for a future frame to run. Force a wait until
 		 * the current frame is finished, and start processing the next
 		 * frame after it's drawn (see the `updated` clause above). */
@@ -436,23 +451,24 @@ void renderer_notify_update_lace(int updated) {
 		/* We are no longer holding commands back, so the next frame may
 		 * get mixed into the following frame. This is usually fine, but can
 		 * result in frameskip-like effects for 60fps games. */
-		hold_cmds = false;
-		needs_display = true;
-		gpu.state.fb_dirty = true;
+		flushed = FALSE;
+		hold_cmds = FALSE;
+		needs_display = TRUE;
+		gpu.state.fb_dirty = TRUE;
 	} else if (thread.queue->used) {
 		/* We are still drawing during a vblank. Cut off the current frame
 		 * by sending new commands to the background queue and skip
 		 * drawing our partly rendered frame to the display. */
-		hold_cmds = true;
-		needs_display = true;
-		gpu.state.fb_dirty = false;
+		hold_cmds = TRUE;
+		needs_display = TRUE;
+		gpu.state.fb_dirty = FALSE;
 	} else if (needs_display && !thread.queue->used) {
 		/* We have processed all commands in the queue, render the
 		 * buffer. We know we have something to render, because
-		 * needs_display is true. */
-		hold_cmds = false;
-		needs_display = false;
-		gpu.state.fb_dirty = true;
+		 * needs_display is TRUE. */
+		hold_cmds = FALSE;
+		needs_display = FALSE;
+		gpu.state.fb_dirty = TRUE;
 	} else {
 		/* Everything went normally, so do the normal thing. */
 	}