rg_display: Replaced rg_display_sync(false) with rg_dysplay_is_busy()

rg_display_sync now has the same meaning as lcd_sync
eg it should sync or flip the framebuffer because we're done drawing it. Maybe it should be called flip, in fact.

Anyway this will improve performance once rg_gui adopts it, instead of calling lcd_sync after each writes (causing over 50 blits to draw one frame of menu)

Author: ducalex

components/retro-go/rg_display.c

@@ -366,6 +366,15 @@ static void display_task(void *arg)
         if (msg.type == RG_TASK_MSG_STOP)
             break;
 
+        const rg_surface_t *update = msg.dataPtr;
+
+        if (display.source.width != update->width || display.source.height != update->height)
+        {
+            display.source.width = update->width;
+            display.source.height = update->height;
+            display.changed = true;
+        }
+
         if (display.changed)
         {
             update_viewport_scaling();
@@ -380,7 +389,7 @@ static void display_task(void *arg)
             display.changed = false;
         }
 
-        write_update(msg.dataPtr);
+        write_update(update);
         // draw_on_screen_display(0, display.screen.height);
         rg_task_receive(&msg, -1);
 
@@ -393,7 +402,9 @@ void rg_display_force_redraw(void)
     display.changed = true;
     // memset(screen_line_checksum, 0, sizeof(screen_line_checksum));
     rg_system_event(RG_EVENT_REDRAW, NULL);
-    rg_display_sync(true);
+    // Wait for the redraw to be complete, if any was initiated!
+    while (rg_display_is_busy())
+        rg_task_yield();
 }
 
 const rg_display_t *rg_display_get_info(void)
@@ -509,25 +520,20 @@ void rg_display_submit(const rg_surface_t *update, uint32_t flags)
     if (!update || !update->data)
         return;
 
-    if (display.source.width != update->width || display.source.height != update->height)
-    {
-        rg_display_sync(true);
-        display.source.width = update->width;
-        display.source.height = update->height;
-        display.changed = true;
-    }
-
     rg_task_send(display_task_queue, &(rg_task_msg_t){.dataPtr = update}, -1);
 
     counters.blockTime += rg_system_timer() - time_start;
     counters.totalFrames++;
 }
 
-bool rg_display_sync(bool block)
+bool rg_display_is_busy(void)
 {
-    while (block && rg_task_messages_waiting(display_task_queue))
-        continue; // We should probably yield?
-    return !rg_task_messages_waiting(display_task_queue);
+    return rg_task_messages_waiting(display_task_queue) != 0;
+}
+
+void rg_display_sync(void)
+{
+    lcd_sync();
 }
 
 // FIXME: We need to add a way to group writes and indicate completion, so that the display driver will blit/flip only
@@ -550,8 +556,11 @@ void rg_display_write_rect(int left, int top, int width, int height, int stride,
     // This will work for now because we rarely draw from different threads (so all we need is ensure
     // that we're not interrupting a display update). But what we SHOULD be doing is acquire a lock
     // before every call to lcd_set_window and release it only after the last call to lcd_send_buffer.
-    if (!(flags & RG_DISPLAY_WRITE_NOSYNC))
-        rg_display_sync(true);
+    if ((flags & RG_DISPLAY_WRITE_NOSYNC) == 0)
+    {
+        while (rg_display_is_busy())
+            rg_task_yield();
+    }
 
     // This isn't really necessary but it makes sense to invalidate
     // the lines we're about to overwrite...
@@ -666,9 +675,10 @@ bool rg_display_set_geometry(int width, int height, const rg_margins_t *margins)
     // update_viewport_scaling();             // This will be implicitly done by the display task
     rg_gui_update_geometry();              // Let the GUI know that the geometry has changed
     rg_system_event(RG_EVENT_GEOMETRY, 0); // Let everybody know that the geometry has changed
-    RG_LOGI("Screen: resolution=%dx%d, effective=%dx%d, format=%d",
-            display.screen.real_width, display.screen.real_height,
-            display.screen.width, display.screen.height, display.screen.format);
+    RG_LOGI("Screen: resolution=%dx%d (eff. %dx%d), margins=(%d %d %d %d), format=%d",
+            display.screen.real_width, display.screen.real_height, display.screen.width, display.screen.height,
+            display.screen.margins.left, display.screen.margins.top, display.screen.margins.right, display.screen.margins.bottom,
+            display.screen.format);
     return true;
 }
 

components/retro-go/rg_display.h

@@ -40,6 +40,7 @@ enum
 {
     RG_DISPLAY_WRITE_NOSYNC = (1 << 0),
     RG_DISPLAY_WRITE_NOSWAP = (1 << 1),
+    RG_DISPLAY_WRITE_DIRECT = (1 << 2),
 };
 
 typedef struct
@@ -107,9 +108,12 @@ void rg_display_write_rect(int left, int top, int width, int height, int stride,
 void rg_display_clear_rect(int left, int top, int width, int height, uint16_t color_le);
 void rg_display_clear_except(int left, int top, int width, int height, uint16_t color_le);
 void rg_display_clear(uint16_t color_le);
-bool rg_display_sync(bool block);
+bool rg_display_is_busy(void);
 void rg_display_force_redraw(void);
 void rg_display_submit(const rg_surface_t *update, uint32_t flags);
+// rg_display_sync syncs our internal state to the display. With ILI9341/ST7789 it's a no-op because all writes
+// are direct. With other drivers it is used to signal that the internal framebuffer should be sent to the LCD.
+void rg_display_sync(void);
 
 rg_display_counters_t rg_display_get_counters(void);
 const rg_display_t *rg_display_get_info(void);

components/retro-go/rg_gui.c

@@ -2215,6 +2215,7 @@ void rg_gui_debug_menu(void)
         rg_system_set_log_level(RG_LOG_DEBUG);
         break;
     case 0x100:
+        rg_display_clear(C_BLACK);
         rg_display_set_geometry(
             RG_MAX(64, (rand() % RG_SCREEN_WIDTH) & ~0x3),
             RG_MAX(64, (rand() % RG_SCREEN_HEIGHT) & ~0x3),

gwenesis/main/main.c

@@ -470,9 +470,9 @@ void app_main(void)
         {
             for (int i = 0; i < 256; ++i)
                 currentUpdate->palette[i] = (CRAM565[i] << 8) | (CRAM565[i] >> 8);
-            slowFrame = !rg_display_sync(false);
             currentUpdate->width = screen_width;
             currentUpdate->height = screen_height;
+            slowFrame = rg_display_is_busy(); // Previous frame is still not done, hence slowFrame...
             rg_display_submit(currentUpdate, 0);
         }
 

launcher/main/gui.c

@@ -372,7 +372,9 @@ void gui_scroll_list(tab_t *tab, scroll_whence_t mode, int arg)
 
 void gui_redraw(void)
 {
-    rg_display_sync(true);
+    while (rg_display_is_busy())
+        rg_task_yield(); // Wait for gui.surface to be released
+
     rg_gui_set_surface(gui.surface);
 
     tab_t *tab = gui_get_current_tab();

prboom-go/main/main.c

@@ -137,12 +137,15 @@ void I_UpdateNoBlit(void)
 void I_FinishUpdate(void)
 {
     rg_display_submit(update, 0);
-    rg_display_sync(true); // Wait for update->buffer to be released
 }
 
 bool I_StartDisplay(void)
 {
+    // Wait for the frame buffer to be released before we start drawing to it
+    while (rg_display_is_busy())
+        rg_task_yield();
     return true;
+    // return !rg_display_is_busy();
 }
 
 void I_EndDisplay(void)

retro-core/main/main_gbc.c

@@ -219,7 +219,7 @@ static rg_gui_event_t rtc_update_cb(rg_gui_option_t *option, rg_gui_event_t even
 static void video_callback(void *buffer)
 {
     int64_t startTime = rg_system_timer();
-    slowFrame = !rg_display_sync(false);
+    slowFrame = rg_display_is_busy();
     rg_display_submit(currentUpdate, 0);
     video_time += rg_system_timer() - startTime;
 }

retro-core/main/main_gw.c

@@ -275,7 +275,7 @@ void gw_main(void)
 
         // Our refresh rate is 128Hz, which is way too fast for our display
         // so make sure the previous frame is done sending before queuing a new one
-        if (rg_display_sync(false) && drawFrame)
+        if (!rg_display_is_busy() && drawFrame)
         {
             gw_system_blit(currentUpdate->data);
             rg_display_submit(currentUpdate, 0);

retro-core/main/main_lynx.cpp

@@ -259,7 +259,7 @@ extern "C" void lynx_main(void)
 
         if (drawFrame)
         {
-            slowFrame = !rg_display_sync(false);
+            slowFrame = rg_display_is_busy();
             rg_display_submit(currentUpdate, 0);
             currentUpdate = updates[currentUpdate == updates[0]];
             gPrimaryFrameBuffer = (UBYTE*)currentUpdate->data;

retro-core/main/main_nes.c

@@ -150,7 +150,7 @@ static rg_gui_event_t palette_update_cb(rg_gui_option_t *option, rg_gui_event_t
 
 static void blit_screen(uint8 *bmp)
 {
-    slowFrame = bmp && !rg_display_sync(false);
+    slowFrame = bmp && rg_display_is_busy();
     // A rolling average should be used for autocrop == 1, it causes jitter in some games...
     // int crop_h = (autocrop == 2) || (autocrop == 1 && nes->ppu->left_bg_counter > 210) ? 8 : 0;
     int crop_v = (overscan) ? nes->overscan : 0;