rg_system: Added app->frameTime to get expected frame time

retro-go now always maintains the expected time a frame should take (time between ticks).

I've added `rg_system_set_tick_rate` to replace `app->tickrate = N` to ensure frameTime is recalculated when tickrate changes.

Author: ducalex

components/retro-go/rg_system.c

@@ -367,6 +367,7 @@ rg_app_t *rg_system_init(int sampleRate, const rg_handlers_t *handlers, const rg
         .speed = 1.f,
         .sampleRate = sampleRate,
         .tickRate = 60,
+        .frameTime = 1000000 / 60,
         .frameskip = 1,
         .overclock = 0,
         .tickTimeout = 3000000,
@@ -772,6 +773,17 @@ rg_stats_t rg_system_get_counters(void)
     return statistics;
 }
 
+void rg_system_set_tick_rate(int tickRate)
+{
+    app.tickRate = tickRate;
+    app.frameTime = 1000000 / (app.tickRate * app.speed);
+}
+
+int rg_system_get_tick_rate(void)
+{
+    return app.tickRate;
+}
+
 void rg_system_tick(int busyTime)
 {
     statistics.lastTick = rg_system_timer();
@@ -1372,8 +1384,8 @@ rg_emu_states_t *rg_emu_get_states(const char *romPath, size_t slots)
 
 bool rg_emu_reset(bool hard)
 {
-    app.frameskip = 0;
-    app.speed = 1.f;
+    app.frameskip = 1;
+    rg_emu_set_speed(1.f);
     if (app.handlers.reset)
         return app.handlers.reset(hard);
     return false;
@@ -1383,6 +1395,7 @@ void rg_emu_set_speed(float speed)
 {
     app.speed = RG_MIN(2.5f, RG_MAX(0.5f, speed));
     app.frameskip = RG_MAX(app.frameskip, (app.speed > 1.0f) ? 2 : 0);
+    app.frameTime = 1000000.f / (app.tickRate * app.speed);
     rg_audio_set_sample_rate(app.sampleRate * app.speed);
     rg_system_event(RG_EVENT_SPEEDUP, NULL);
 }

components/retro-go/rg_system.h

@@ -177,6 +177,7 @@ typedef struct
     float speed;
     int sampleRate;
     int tickRate;
+    int frameTime;
     int frameskip;
     int overclock;
     int tickTimeout;
@@ -227,6 +228,8 @@ void rg_system_set_indicator(rg_indicator_t indicator, bool on);
 bool rg_system_get_indicator(rg_indicator_t indicator);
 void rg_system_set_indicator_mask(rg_indicator_t indicator, bool on);
 bool rg_system_get_indicator_mask(rg_indicator_t indicator);
+void rg_system_set_tick_rate(int tickRate);
+int rg_system_get_tick_rate(void);
 void rg_system_set_overclock(int level);
 int  rg_system_get_overclock(void);
 void rg_system_set_log_level(rg_log_level_t level);

fmsx/main/main.c

@@ -438,7 +438,7 @@ void app_main(void)
 
     app = rg_system_init(AUDIO_SAMPLE_RATE, &handlers, options);
     // This is probably not right, but the emulator outputs 440 samples per frame??
-    app->tickRate = 55;
+    rg_system_set_tick_rate(55);
 
     updates[0] = rg_surface_create(WIDTH, HEIGHT, RG_PIXEL_565_BE, MEM_FAST);
     updates[1] = rg_surface_create(WIDTH, HEIGHT, RG_PIXEL_565_BE, MEM_FAST);

gwenesis/main/main.c

@@ -253,8 +253,8 @@ void app_main(void)
         rg_emu_load_state(app->saveSlot);
     }
 
-    app->tickRate = 60;
-    app->frameskip = 3;
+    rg_system_set_tick_rate(60);
+    rg_system_set_frame_skip(3, 15, true);
 
     extern unsigned char gwenesis_vdp_regs[0x20];
     extern unsigned int gwenesis_vdp_status;
@@ -402,11 +402,10 @@ void app_main(void)
 
         if (skipFrames == 0)
         {
-            int frameTime = 1000000 / (app->tickRate * app->speed);
             int elapsed = rg_system_timer() - startTime;
             if (app->frameskip > 0)
                 skipFrames = app->frameskip;
-            else if (elapsed > frameTime + 1500) // Allow some jitter
+            else if (elapsed > app->frameTime + 1500) // Allow some jitter
                 skipFrames = 1; // (elapsed / frameTime)
             else if (drawFrame && slowFrame)
                 skipFrames = 1;

prboom-go/main/main.c

@@ -539,7 +539,7 @@ void app_main()
     };
 
     app = rg_system_init(AUDIO_SAMPLE_RATE, &handlers, options);
-    app->tickRate = TICRATE;
+    rg_system_set_tick_rate(TICRATE);
 
     const rg_display_t *display = rg_display_get_info();
     SCREENWIDTH = RG_MIN(display->screen.width, MAX_SCREENWIDTH);

retro-core/main/main_gbc.c

@@ -373,11 +373,10 @@ void gbc_main(void)
 
         if (skipFrames == 0)
         {
-            int frameTime = 1000000 / (app->tickRate * app->speed);
             int elapsed = rg_system_timer() - startTime;
             if (app->frameskip > 0)
                 skipFrames = app->frameskip;
-            else if (elapsed > frameTime + 1500) // Allow some jitter
+            else if (elapsed > app->frameTime + 1500) // Allow some jitter
                 skipFrames = 1; // (elapsed / frameTime)
             else if (drawFrame && slowFrame)
                 skipFrames = 1;

retro-core/main/main_gw.c

@@ -139,7 +139,6 @@ void gw_main(void)
     };
 
     app = rg_system_reinit(AUDIO_SAMPLE_RATE, &handlers, options);
-    app->tickRate = GW_REFRESH_RATE;
 
     updates[0] = rg_surface_create(GW_SCREEN_WIDTH, GW_SCREEN_HEIGHT, RG_PIXEL_565_LE, MEM_FAST);
     currentUpdate = updates[0];
@@ -228,6 +227,8 @@ void gw_main(void)
     /*** Main emulator loop */
     printf("Main emulator loop start\n");
 
+    rg_system_set_tick_rate(GW_REFRESH_RATE);
+
     while (true)
     {
         /* refresh internal G&W timer on emulated CPU state transition */

retro-core/main/main_lynx.cpp

@@ -201,9 +201,6 @@ extern "C" void lynx_main(void)
     updates[1] = rg_surface_create(HANDY_SCREEN_WIDTH, HANDY_SCREEN_WIDTH, RG_PIXEL_565_BE, MEM_FAST);
     currentUpdate = updates[0];
 
-    // The Lynx has a variable framerate but 60 is typical
-    app->tickRate = 60;
-
     // Init emulator
     lynx = new_lynx();
 
@@ -223,7 +220,6 @@ extern "C" void lynx_main(void)
 
     set_display_mode();
 
-    float sampleTime = 1000000.f / app->sampleRate;
     long skipFrames = 0;
     bool slowFrame = false;
 
@@ -238,7 +234,6 @@ extern "C" void lynx_main(void)
                 rg_gui_game_menu();
             else
                 rg_gui_options_menu();
-            sampleTime = 1000000.f / (app->sampleRate * app->speed);
         }
 
         int64_t startTime = rg_system_timer();
@@ -265,20 +260,20 @@ extern "C" void lynx_main(void)
             gPrimaryFrameBuffer = (UBYTE*)currentUpdate->data;
         }
 
-        app->tickRate = AUDIO_SAMPLE_RATE / (gAudioBufferPointer / 2);
+        // The Lynx has a variable tick rate, I don't know of a better way to guess than from audio stream
+        rg_system_set_tick_rate(AUDIO_SAMPLE_RATE / (gAudioBufferPointer / 2));
         rg_system_tick(rg_system_timer() - startTime);
 
         rg_audio_submit(audioBuffer, gAudioBufferPointer >> 1);
 
         // See if we need to skip a frame to keep up
         if (skipFrames == 0)
         {
-            int frameTime = ((gAudioBufferPointer / 2) * sampleTime);
             int elapsed = rg_system_timer() - startTime;
             if (app->frameskip > 0)
                 skipFrames = app->frameskip;
             // The Lynx uses a variable framerate so we use the count of generated audio samples as reference instead
-            else if (elapsed > frameTime + 1500)
+            else if (elapsed > app->frameTime + 1500)
                 skipFrames = 1; // (elapsed / frameTime)
             else if (drawFrame && slowFrame)
                 skipFrames = 1;

retro-core/main/main_nes.c

@@ -233,7 +233,6 @@ void nes_main(void)
     else if (ret < 0)
         RG_PANIC("Unsupported ROM.");
 
-    app->tickRate = nes->refresh_rate;
     nes->blit_func = blit_screen;
 
     nsfPlayer = nes->cart->type == ROM_TYPE_NSF;
@@ -252,6 +251,8 @@ void nes_main(void)
         rg_emu_load_state(app->saveSlot);
     }
 
+    rg_system_set_tick_rate(nes->refresh_rate);
+
     int skipFrames = 0;
 
     while (true)

retro-core/main/main_pce.c

@@ -74,7 +74,7 @@ void osd_vsync(void)
     }
 
     int64_t curtime = rg_system_timer();
-    int frameTime = 1000000 / (app->tickRate * app->speed);
+    int frameTime = app->frameTime;
     int sleep = frameTime - (curtime - lasttime);
 
     if (sleep > frameTime)
@@ -238,7 +238,7 @@ void pce_main(void)
         rg_emu_load_state(app->saveSlot);
     }
 
-    app->tickRate = 60;
+    rg_system_set_tick_rate(60);
     app->frameskip = 1;
 
     emulationPaused = false;