rg_system: Add timeout parameter to the task messaging functions

Author: ducalex

components/retro-go/rg_display.c

@@ -347,7 +347,7 @@ static void display_task(void *arg)
 {
     rg_task_msg_t msg;
 
-    while (rg_task_peek(&msg))
+    while (rg_task_peek(&msg, -1))
     {
         // Received a shutdown request!
         if (msg.type == RG_TASK_MSG_STOP)
@@ -369,7 +369,7 @@ static void display_task(void *arg)
 
         write_update(msg.dataPtr);
         // draw_on_screen_display(0, display.screen.height);
-        rg_task_receive(&msg);
+        rg_task_receive(&msg, -1);
 
         lcd_sync();
     }
@@ -504,7 +504,7 @@ void rg_display_submit(const rg_surface_t *update, uint32_t flags)
         display.changed = true;
     }
 
-    rg_task_send(display_task_queue, &(rg_task_msg_t){.dataPtr = update});
+    rg_task_send(display_task_queue, &(rg_task_msg_t){.dataPtr = update}, -1);
 
     counters.blockTime += rg_system_timer() - time_start;
     counters.totalFrames++;
@@ -615,7 +615,7 @@ void rg_display_clear(uint16_t color_le)
 
 void rg_display_deinit(void)
 {
-    rg_task_send(display_task_queue, &(rg_task_msg_t){.type = RG_TASK_MSG_STOP});
+    rg_task_send(display_task_queue, &(rg_task_msg_t){.type = RG_TASK_MSG_STOP}, -1);
     // lcd_set_backlight(0);
     lcd_deinit();
     RG_LOGI("Display terminated.\n");

components/retro-go/rg_system.c

@@ -491,12 +491,6 @@ rg_app_t *rg_system_init(const rg_config_t *config)
         app.sampleRate = config->sampleRate;
         app.tickRate = config->frameRate;
         // app.frameskip = config->frameSkip;
-        if (config->mallocAlwaysInternal > 0)
-        {
-            #ifdef ESP_PLATFORM
-            heap_caps_malloc_extmem_enable(config->mallocAlwaysInternal);
-            #endif
-        }
         if (config->storageRequired && !rg_storage_ready())
         {
             rg_display_clear(C_SKY_BLUE);
@@ -506,6 +500,13 @@ rg_app_t *rg_system_init(const rg_config_t *config)
         if (config->romRequired && !app.romPath && !*app.romPath)
         {
             // show rom picking dialog
+            // app.romPath = rg_gui_file_picker(_("Choose ROM"), RG_BASE_PATH_ROMS, NULL, true, false);
+        }
+        if (config->mallocAlwaysInternal > 0)
+        {
+        #ifdef ESP_PLATFORM
+            heap_caps_malloc_extmem_enable(config->mallocAlwaysInternal);
+        #endif
         }
         app.isLauncher = config->isLauncher;
         app.handlers = config->handlers;
@@ -641,11 +642,12 @@ rg_task_t *rg_task_current(void)
     return NULL;
 }
 
-bool rg_task_send(rg_task_t *task, const rg_task_msg_t *msg)
+bool rg_task_send(rg_task_t *task, const rg_task_msg_t *msg, int timeoutMS)
 {
     RG_ASSERT_ARG(task && msg);
 #if defined(ESP_PLATFORM)
-    return xQueueSend(task->queue, msg, portMAX_DELAY) == pdTRUE;
+    TickType_t timeout = timeoutMS < 0 ? portMAX_DELAY : pdMS_TO_TICKS(timeoutMS);
+    return xQueueSend(task->queue, msg, timeout) == pdTRUE;
 #elif defined(RG_TARGET_SDL2)
     while (task->msgWaiting > 0)
         continue;
@@ -655,15 +657,16 @@ bool rg_task_send(rg_task_t *task, const rg_task_msg_t *msg)
 #endif
 }
 
-bool rg_task_peek(rg_task_msg_t *out)
+bool rg_task_peek(rg_task_msg_t *out, int timeoutMS)
 {
     rg_task_t *task = rg_task_current();
     bool success = false;
     if (!task || !out)
         return false;
     // task->blocked = true;
 #if defined(ESP_PLATFORM)
-    success = xQueuePeek(task->queue, out, portMAX_DELAY) == pdTRUE;
+    TickType_t timeout = timeoutMS < 0 ? portMAX_DELAY : pdMS_TO_TICKS(timeoutMS);
+    success = xQueuePeek(task->queue, out, timeout) == pdTRUE;
 #elif defined(RG_TARGET_SDL2)
     while (task->msgWaiting < 1)
         continue;
@@ -673,15 +676,16 @@ bool rg_task_peek(rg_task_msg_t *out)
     return success;
 }
 
-bool rg_task_receive(rg_task_msg_t *out)
+bool rg_task_receive(rg_task_msg_t *out, int timeoutMS)
 {
     rg_task_t *task = rg_task_current();
     bool success = false;
     if (!task || !out)
         return false;
     // task->blocked = true;
 #if defined(ESP_PLATFORM)
-    success = xQueueReceive(task->queue, out, portMAX_DELAY) == pdTRUE;
+    TickType_t timeout = timeoutMS < 0 ? portMAX_DELAY : pdMS_TO_TICKS(timeoutMS);
+    success = xQueueReceive(task->queue, out, timeout) == pdTRUE;
 #elif defined(RG_TARGET_SDL2)
     while (task->msgWaiting < 1)
         continue;
@@ -759,7 +763,7 @@ bool rg_mutex_take(rg_mutex_t *mutex, int timeoutMS)
 {
     RG_ASSERT_ARG(mutex);
 #if defined(ESP_PLATFORM)
-    int timeout = timeoutMS >= 0 ? pdMS_TO_TICKS(timeoutMS) : portMAX_DELAY;
+    int timeout = timeoutMS < 0 ? portMAX_DELAY : pdMS_TO_TICKS(timeoutMS);
     return xSemaphoreTake((QueueHandle_t)mutex, timeout) == pdPASS;
 #elif defined(RG_TARGET_SDL2)
     return SDL_LockMutex((SDL_mutex *)mutex) == 0;

components/retro-go/rg_system.h

@@ -255,9 +255,9 @@ typedef struct
 rg_task_t *rg_task_create(const char *name, void (*taskFunc)(void *arg), void *arg, size_t stackSize, int priority, int affinity);
 rg_task_t *rg_task_find(const char *name);
 rg_task_t *rg_task_current(void);
-bool rg_task_send(rg_task_t *task, const rg_task_msg_t *msg);
-bool rg_task_peek(rg_task_msg_t *out);
-bool rg_task_receive(rg_task_msg_t *out);
+bool rg_task_send(rg_task_t *task, const rg_task_msg_t *msg, int timeoutMS);
+bool rg_task_peek(rg_task_msg_t *out, int timeoutMS);
+bool rg_task_receive(rg_task_msg_t *out, int timeoutMS);
 bool rg_task_is_blocked(rg_task_t *task);
 size_t rg_task_messages_waiting(rg_task_t *task);
 // The main difference between rg_task_delay and rg_usleep is that rg_task_delay will yield

fmsx/main/main.c

@@ -335,8 +335,8 @@ unsigned int GetFreeAudio(void)
 void PlayAllSound(int uSec)
 {
     int64_t start = rg_system_timer();
-    unsigned int samples = 2 * uSec * AUDIO_SAMPLE_RATE / 1000000;
-    rg_task_send(audioQueue, &(rg_task_msg_t){.dataInt = samples});
+    rg_task_msg_t msg = {.dataInt = 2 * uSec * AUDIO_SAMPLE_RATE / 1000000};
+    rg_task_send(audioQueue, &msg, -1);
     FrameStartTime += rg_system_timer() - start;
 }
 
@@ -403,10 +403,10 @@ static void audioTask(void *arg)
 {
     RG_LOGI("task started");
     rg_task_msg_t msg;
-    while (rg_task_peek(&msg))
+    while (rg_task_peek(&msg, -1))
     {
         RenderAndPlayAudio(msg.dataInt);
-        rg_task_receive(&msg);
+        rg_task_receive(&msg, -1);
     }
 }
 

gwenesis/main/main.c

@@ -218,7 +218,7 @@ static rg_gui_event_t core1_sound_update_cb(rg_gui_option_t *option, rg_gui_even
 static void core1_task(void *arg)
 {
     rg_task_msg_t msg;
-    while (rg_task_receive(&msg))
+    while (rg_task_receive(&msg, -1))
     {
         switch (msg.type)
         {
@@ -391,7 +391,8 @@ void app_main(void)
             if (GWENESIS_AUDIO_ACCURATE == 0) {
                 if (core1_task_sound)
                 {
-                    rg_task_send(core1_task_handle, &(rg_task_msg_t){.type = 2, .dataInt = system_clock + VDP_CYCLES_PER_LINE});
+                    rg_task_msg_t msg = {.type = 2, .dataInt = system_clock + VDP_CYCLES_PER_LINE};
+                    rg_task_send(core1_task_handle, &msg, -1);
                 }
                 else
                 {
@@ -404,7 +405,7 @@ void app_main(void)
             if (drawFrame && scan_line < screen_height)
             {
                 if (core1_task_rendering)
-                    rg_task_send(core1_task_handle, &(rg_task_msg_t){.type = 1, .dataInt = scan_line});
+                    rg_task_send(core1_task_handle, &(rg_task_msg_t){.type = 1, .dataInt = scan_line}, -1);
                 else
                     gwenesis_vdp_render_line(scan_line); /* render scan_line */
             }
@@ -448,8 +449,9 @@ void app_main(void)
         // Make sure all our previous messages have been processed before we continue
         if (core1_task_rendering || core1_task_sound)
         {
-            rg_task_send(core1_task_handle, &(rg_task_msg_t){0});
-            rg_task_send(core1_task_handle, &(rg_task_msg_t){0});
+            const rg_task_msg_t msg = {0};
+            rg_task_send(core1_task_handle, &msg, -1);
+            rg_task_send(core1_task_handle, &msg, -1);
         }
 
         /* Audio

snes9x/main/main_snes.c

@@ -312,7 +312,7 @@ static void audio_task(void *arg)
     rg_audio_sample_t *audioBuffer = rg_alloc(AUDIO_BUFFER_LENGTH * 4, MEM_FAST);
     rg_task_msg_t msg;
     bool zeroed = false;
-    while (rg_task_receive(&msg))
+    while (rg_task_receive(&msg, -1))
     {
         if (msg.type == RG_TASK_MSG_STOP)
             break;
@@ -491,7 +491,7 @@ void app_main(void)
         rg_system_tick(rg_system_timer() - startTime);
         rg_task_msg_t msg = {.type = (int)sound_enabled, .dataInt = samples};
         if (sound_enabled || app->frameTime - (rg_system_timer() - startTime) > 2000)
-            rg_task_send(audio_task_handle, &msg);
+            rg_task_send(audio_task_handle, &msg, -1);
     #else
         if (sound_enabled && lowpass_filter)
             S9xMixSamplesLowPass((int16_t *)audioBuffer, samples << 1, AUDIO_LOW_PASS_RANGE);