OpenDingux Beta: Add 50Hz support

config.def.h

@@ -37,7 +37,8 @@
 #include "gfx/common/ctr_common.h"
 #endif
 
-/* Required for OpenDingux IPU filter setting */
+/* Required for OpenDingux IPU filter + refresh
+ * rate settings */
 #if defined(DINGUX)
 #include "dingux/dingux_utils.h"
 #endif
@@ -383,6 +384,11 @@
 /* Sets image filtering method when using the
  * IPU hardware scaler in Dingux devices */
 #define DEFAULT_DINGUX_IPU_FILTER_TYPE DINGUX_IPU_FILTER_BICUBIC
+#if defined(DINGUX_BETA)
+/* Sets refresh rate of integral LCD panel
+ * in Dingux devices */
+#define DEFAULT_DINGUX_REFRESH_RATE DINGUX_REFRESH_RATE_60HZ
+#endif
 #endif
 
 /* Save configuration file on exit. */
@@ -875,8 +881,15 @@ static const bool audio_enable_menu_bgm    = false;
 #define DEFAULT_NOTIFICATION_SHOW_SCREENSHOT_FLASH 0
 #endif
 
-/*Display a notification when setting the refresh rate*/
+/* Display a notification when setting the refresh rate*/
+#if defined(_3DS) || (defined(DINGUX) && defined(DINGUX_BETA))
+/* 3DS and OpenDingux Beta devices set refresh rate
+ * on gfx driver init - set default notification
+ * state to 'false' in order to avoid OSD log spam */
+#define DEFAULT_NOTIFICATION_SHOW_REFRESH_RATE false
+#else
 #define DEFAULT_NOTIFICATION_SHOW_REFRESH_RATE true
+#endif
 
 /* Output samplerate. */
 #ifdef GEKKO

configuration.c

@@ -2049,6 +2049,9 @@ static struct config_uint_setting *populate_settings_uint(
 
 #if defined(DINGUX)
    SETTING_UINT("video_dingux_ipu_filter_type", &settings->uints.video_dingux_ipu_filter_type, true, DEFAULT_DINGUX_IPU_FILTER_TYPE, false);
+#if defined(DINGUX_BETA)
+   SETTING_UINT("video_dingux_refresh_rate",    &settings->uints.video_dingux_refresh_rate, true, DEFAULT_DINGUX_REFRESH_RATE, false);
+#endif
 #endif
 
 #ifdef HAVE_MENU

configuration.h

@@ -201,6 +201,7 @@ typedef struct settings
       unsigned video_stream_scale_factor;
       unsigned video_3ds_display_mode;
       unsigned video_dingux_ipu_filter_type;
+      unsigned video_dingux_refresh_rate;
 #ifdef HAVE_VIDEO_LAYOUT
       unsigned video_layout_selected_view;
 #endif

dingux/dingux_utils.c

@@ -19,6 +19,7 @@
 #include <streams/file_stream.h>
 
 #if defined(DINGUX_BETA)
+#include <string/stdstring.h>
 #include <stdlib.h>
 #endif
 
@@ -37,6 +38,7 @@
 #define DINGUX_BATTERY_VOLTAGE_NOW        "/sys/class/power_supply/jz-battery/voltage_now"
 #define DINGUX_SCALING_MODE_ENVAR         "SDL_VIDEO_KMSDRM_SCALING_MODE"
 #define DINGUX_SCALING_SHARPNESS_ENVAR    "SDL_VIDEO_KMSDRM_SCALING_SHARPNESS"
+#define DINGUX_VIDEO_REFRESHRATE_ENVAR    "SDL_VIDEO_REFRESHRATE"
 
 /* Enables/disables downscaling when using
  * the IPU hardware scaler */
@@ -162,6 +164,63 @@ bool dingux_ipu_set_filter_type(enum dingux_ipu_filter_type filter_type)
 #endif
 }
 
+#if defined(DINGUX_BETA)
+/* Sets the refresh rate of the integral LCD panel.
+ * If specified value is invalid, will set refresh
+ * rate to 60 Hz.
+ * Returns a floating point representation of the
+ * resultant hardware refresh rate. In the event
+ * that a refresh rate cannot be set (i.e. hardware
+ * error), returns 0.0 */
+float dingux_set_video_refresh_rate(enum dingux_refresh_rate refresh_rate)
+{
+   float refresh_rate_float     = 60.0f;
+   const char *refresh_rate_str = "60";
+
+   /* Check filter type */
+   switch (refresh_rate)
+   {
+      case DINGUX_REFRESH_RATE_50HZ:
+         refresh_rate_float = 50.0f;
+         refresh_rate_str   = "50";
+         break;
+      default:
+         /* Refresh rate is already set to 60 Hz
+          * by default */
+         break;
+   }
+
+   if (setenv(DINGUX_VIDEO_REFRESHRATE_ENVAR, refresh_rate_str, 1) != 0)
+      refresh_rate_float = 0.0f;
+
+   return refresh_rate_float;
+}
+
+/* Gets the currently set refresh rate of the
+ * integral LCD panel. */
+bool dingux_get_video_refresh_rate(enum dingux_refresh_rate *refresh_rate)
+{
+   const char *refresh_rate_str = getenv(DINGUX_VIDEO_REFRESHRATE_ENVAR);
+
+   /* If environment variable is unset, refresh
+    * rate defaults to 60 Hz */
+   if (!refresh_rate_str)
+   {
+      *refresh_rate = DINGUX_REFRESH_RATE_60HZ;
+      return true;
+   }
+
+   if (string_is_equal(refresh_rate_str, "60"))
+      *refresh_rate = DINGUX_REFRESH_RATE_60HZ;
+   else if (string_is_equal(refresh_rate_str, "50"))
+      *refresh_rate = DINGUX_REFRESH_RATE_50HZ;
+   else
+      return false;
+
+   return true;
+}
+#endif
+
 /* Resets the IPU hardware scaler to the
  * default configuration */
 bool dingux_ipu_reset(void)
@@ -169,6 +228,7 @@ bool dingux_ipu_reset(void)
 #if defined(DINGUX_BETA)
    unsetenv(DINGUX_SCALING_MODE_ENVAR);
    unsetenv(DINGUX_SCALING_SHARPNESS_ENVAR);
+   unsetenv(DINGUX_VIDEO_REFRESHRATE_ENVAR);
    return true;
 #else
    return dingux_ipu_set_scaling_mode(true, false) &&

dingux/dingux_utils.h

@@ -38,6 +38,17 @@ enum dingux_ipu_filter_type
    DINGUX_IPU_FILTER_LAST
 };
 
+#if defined(DINGUX_BETA)
+/* Specifies all video refresh rates supported
+ * by OpenDingux Beta */
+enum dingux_refresh_rate
+{
+   DINGUX_REFRESH_RATE_60HZ = 0,
+   DINGUX_REFRESH_RATE_50HZ,
+   DINGUX_REFRESH_RATE_LAST
+};
+#endif
+
 /* Enables/disables downscaling when using
  * the IPU hardware scaler */
 bool dingux_ipu_set_downscaling_enable(bool enable);
@@ -66,6 +77,23 @@ bool dingux_ipu_set_scaling_mode(bool keep_aspect, bool integer_scale);
  * using the IPU hardware scaler */
 bool dingux_ipu_set_filter_type(enum dingux_ipu_filter_type filter_type);
 
+#if defined(DINGUX_BETA)
+/* Sets the refresh rate of the integral LCD panel.
+ * If specified value is invalid, will set refresh
+ * rate to 60 Hz.
+ * Returns a floating point representation of the
+ * resultant hardware refresh rate. In the event
+ * that a refresh rate cannot be set (i.e. hardware
+ * error), returns 0.0 */
+float dingux_set_video_refresh_rate(enum dingux_refresh_rate refresh_rate);
+
+/* Gets the currently set refresh rate of the
+ * integral LCD panel.
+ * Returns false if hardware is in an undefined
+ * state. */
+bool dingux_get_video_refresh_rate(enum dingux_refresh_rate *refresh_rate);
+#endif
+
 /* Resets the IPU hardware scaler to the
  * default configuration */
 bool dingux_ipu_reset(void);

gfx/drivers/sdl_dingux_gfx.c

@@ -42,6 +42,9 @@
 #include "../../gfx/drivers_font_renderer/bitmap.h"
 #include "../../configuration.h"
 #include "../../retroarch.h"
+#if defined(DINGUX_BETA)
+#include "../../driver.h"
+#endif
 
 #define likely(x)   __builtin_expect(!!(x), 1)
 #define unlikely(x) __builtin_expect(!!(x), 0)
@@ -51,11 +54,10 @@
 
 #define SDL_DINGUX_NUM_FONT_GLYPHS 256
 
-#define SDL_DINGUX_FF_FRAME_TIME_MIN 16667
-
 typedef struct sdl_dingux_video
 {
    retro_time_t last_frame_time;
+   retro_time_t ff_frame_time_min;
    SDL_Surface *screen;
    bitmapfont_lut_t *osd_font;
    unsigned frame_width;
@@ -63,6 +65,9 @@ typedef struct sdl_dingux_video
    unsigned frame_padding_x;
    unsigned frame_padding_y;
    enum dingux_ipu_filter_type filter_type;
+#if defined(DINGUX_BETA)
+   enum dingux_refresh_rate refresh_rate;
+#endif
    uint32_t font_colour32;
    uint16_t font_colour16;
    uint16_t menu_texture[SDL_DINGUX_MENU_WIDTH * SDL_DINGUX_MENU_HEIGHT];
@@ -402,16 +407,23 @@ static void sdl_dingux_input_driver_init(
 static void *sdl_dingux_gfx_init(const video_info_t *video,
       input_driver_t **input, void **input_data)
 {
-   sdl_dingux_video_t *vid                     = NULL;
+   sdl_dingux_video_t *vid                       = NULL;
-   uint32_t sdl_subsystem_flags                = SDL_WasInit(0);
+   uint32_t sdl_subsystem_flags                  = SDL_WasInit(0);
-   settings_t *settings                        = config_get_ptr();
+   settings_t *settings                          = config_get_ptr();
-   bool ipu_keep_aspect                        = settings->bools.video_dingux_ipu_keep_aspect;
+   bool ipu_keep_aspect                          = settings->bools.video_dingux_ipu_keep_aspect;
-   bool ipu_integer_scaling                    = settings->bools.video_scale_integer;
+   bool ipu_integer_scaling                      = settings->bools.video_scale_integer;
-   enum dingux_ipu_filter_type ipu_filter_type = (enum dingux_ipu_filter_type)
+#if defined(DINGUX_BETA)
+   enum dingux_refresh_rate current_refresh_rate = DINGUX_REFRESH_RATE_60HZ;
+   enum dingux_refresh_rate target_refresh_rate  = (enum dingux_refresh_rate)
+         settings->uints.video_dingux_refresh_rate;
+   bool refresh_rate_valid                       = false;
+   float hw_refresh_rate                         = 0.0f;
+#endif
+   enum dingux_ipu_filter_type ipu_filter_type   = (enum dingux_ipu_filter_type)
          settings->uints.video_dingux_ipu_filter_type;
-   const char *input_driver_name               = settings->arrays.input_driver;
+   const char *input_driver_name                 = settings->arrays.input_driver;
-   const char *joypad_driver_name              = settings->arrays.input_joypad_driver;
+   const char *joypad_driver_name                = settings->arrays.input_joypad_driver;
-   uint32_t surface_flags                      = (video->vsync) ?
+   uint32_t surface_flags                        = (video->vsync) ?
          (SDL_HWSURFACE | SDL_TRIPLEBUF | SDL_FULLSCREEN) :
          (SDL_HWSURFACE | SDL_FULLSCREEN);
 
@@ -434,6 +446,50 @@ static void *sdl_dingux_gfx_init(const video_info_t *video,
    dingux_ipu_set_downscaling_enable(true);
    dingux_ipu_set_scaling_mode(ipu_keep_aspect, ipu_integer_scaling);
    dingux_ipu_set_filter_type(ipu_filter_type);
+#if defined(DINGUX_BETA)
+   /* Get current refresh rate */
+   refresh_rate_valid = dingux_get_video_refresh_rate(&current_refresh_rate);
+
+   /* Check if refresh rate needs to be updated */
+   if (!refresh_rate_valid ||
+       (current_refresh_rate != target_refresh_rate))
+      hw_refresh_rate = dingux_set_video_refresh_rate(target_refresh_rate);
+   else
+   {
+      /* Correct refresh rate is already set,
+       * just convert to float */
+      switch (current_refresh_rate)
+      {
+         case DINGUX_REFRESH_RATE_50HZ:
+            hw_refresh_rate = 50.0f;
+            break;
+         default:
+            hw_refresh_rate = 60.0f;
+            break;
+      }
+   }
+
+   if (hw_refresh_rate == 0.0f)
+   {
+      RARCH_ERR("[SDL1]: Failed to set video refresh rate\n");
+      goto error;
+   }
+
+   vid->refresh_rate = target_refresh_rate;
+   switch (target_refresh_rate)
+   {
+      case DINGUX_REFRESH_RATE_50HZ:
+         vid->ff_frame_time_min = 20000;
+         break;
+      default:
+         vid->ff_frame_time_min = 16667;
+         break;
+   }
+
+   driver_ctl(RARCH_DRIVER_CTL_SET_REFRESH_RATE, &hw_refresh_rate);
+#else
+   vid->ff_frame_time_min = 16667;
+#endif
 
    vid->screen = SDL_SetVideoMode(
          SDL_DINGUX_MENU_WIDTH, SDL_DINGUX_MENU_HEIGHT,
@@ -710,7 +766,8 @@ static bool sdl_dingux_gfx_frame(void *data, const void *frame,
 
    /* If fast forward is currently active, we may
     * push frames at an 'unlimited' rate. Since the
-    * display has a fixed refresh rate of 60 Hz, this
+    * display has a fixed refresh rate of 60 Hz (or
+    * potentially 50 Hz on OpenDingux Beta), this
     * represents wasted effort. We therefore drop any
     * 'excess' frames in this case.
     * (Note that we *only* do this when fast forwarding.
@@ -721,7 +778,7 @@ static bool sdl_dingux_gfx_frame(void *data, const void *frame,
       retro_time_t current_time = cpu_features_get_time_usec();
 
       if ((current_time - vid->last_frame_time) <
-            SDL_DINGUX_FF_FRAME_TIME_MIN)
+            vid->ff_frame_time_min)
          return true;
 
       vid->last_frame_time = current_time;
@@ -932,6 +989,26 @@ static void sdl_dingux_gfx_viewport_info(void *data, struct video_viewport *vp)
    vp->height = vp->full_height = vid->frame_height;
 }
 
+static float sdl_dingux_get_refresh_rate(void *data)
+{
+#if defined(DINGUX_BETA)
+   sdl_dingux_video_t *vid = (sdl_dingux_video_t*)data;
+
+   if (!vid)
+      return 0.0f;
+
+   switch (vid->refresh_rate)
+   {
+      case DINGUX_REFRESH_RATE_50HZ:
+         return 50.0f;
+      default:
+         break;
+   }
+#endif
+
+   return 60.0f;
+}
+
 static void sdl_dingux_set_filtering(void *data, unsigned index, bool smooth, bool ctx_scaling)
 {
    sdl_dingux_video_t *vid                     = (sdl_dingux_video_t*)data;
@@ -1000,7 +1077,7 @@ static const video_poke_interface_t sdl_dingux_poke_interface = {
    NULL,
    NULL,
    NULL,
-   NULL, /* get_refresh_rate */
+   sdl_dingux_get_refresh_rate,
    sdl_dingux_set_filtering,
    NULL, /* get_video_output_size */
    NULL, /* get_video_output_prev */

intl/msg_hash_lbl.h

@@ -3135,6 +3135,12 @@ MSG_HASH(
    MENU_ENUM_LABEL_VIDEO_DINGUX_IPU_FILTER_TYPE,
    "video_dingux_ipu_filter_type"
    )
+#if defined(DINGUX_BETA)
+MSG_HASH(
+   MENU_ENUM_LABEL_VIDEO_DINGUX_REFRESH_RATE,
+   "video_dingux_refresh_rate"
+   )
+#endif
 #endif
 MSG_HASH(
    MENU_ENUM_LABEL_VIDEO_BLACK_FRAME_INSERTION,

intl/msg_hash_us.h

@@ -1500,6 +1500,24 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_VIDEO_REFRESH_RATE_POLLED,
    "The refresh rate as reported by the display driver."
    )
+#if defined(DINGUX) && defined(DINGUX_BETA)
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_REFRESH_RATE,
+   "Vertical Refresh Rate"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_VIDEO_DINGUX_REFRESH_RATE,
+   "Set vertical refresh rate of the display. '50 Hz' will enable smooth video when running PAL content."
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_REFRESH_RATE_60HZ,
+   "60 Hz"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_REFRESH_RATE_50HZ,
+   "50 Hz"
+   )
+#endif
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_VIDEO_FORCE_SRGB_DISABLE,
    "Force-Disable sRGB FBO"

menu/cbs/menu_cbs_sublabel.c

@@ -856,6 +856,9 @@ DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_video_aspect_ratio,
 #if defined(DINGUX)
 DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_video_dingux_ipu_keep_aspect,          MENU_ENUM_SUBLABEL_VIDEO_DINGUX_IPU_KEEP_ASPECT)
 DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_video_dingux_ipu_filter_type,          MENU_ENUM_SUBLABEL_VIDEO_DINGUX_IPU_FILTER_TYPE)
+#if defined(DINGUX_BETA)
+DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_video_dingux_refresh_rate,             MENU_ENUM_SUBLABEL_VIDEO_DINGUX_REFRESH_RATE)
+#endif
 #endif
 DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_video_viewport_custom_height,          MENU_ENUM_SUBLABEL_VIDEO_VIEWPORT_CUSTOM_HEIGHT)
 DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_video_viewport_custom_width,           MENU_ENUM_SUBLABEL_VIDEO_VIEWPORT_CUSTOM_WIDTH)
@@ -1860,6 +1863,11 @@ int menu_cbs_init_bind_sublabel(menu_file_list_cbs_t *cbs,
          case MENU_ENUM_LABEL_VIDEO_DINGUX_IPU_FILTER_TYPE:
             BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_video_dingux_ipu_filter_type);
             break;
+#if defined(DINGUX_BETA)
+         case MENU_ENUM_LABEL_VIDEO_DINGUX_REFRESH_RATE:
+            BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_video_dingux_refresh_rate);
+            break;
+#endif
 #endif
          case MENU_ENUM_LABEL_CORE_INFORMATION:
             BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_core_information);

menu/menu_displaylist.c

@@ -7478,6 +7478,12 @@ unsigned menu_displaylist_build_list(
                      MENU_ENUM_LABEL_VIDEO_GPU_INDEX,
                      PARSE_ONLY_INT, false) == 0)
                count++;
+#if defined(DINGUX) && defined(DINGUX_BETA)
+            if (MENU_DISPLAYLIST_PARSE_SETTINGS_ENUM(list,
+                     MENU_ENUM_LABEL_VIDEO_DINGUX_REFRESH_RATE,
+                     PARSE_ONLY_UINT, false) == 0)
+               count++;
+#endif
             if (threaded && !*threaded)
             {
                if (MENU_DISPLAYLIST_PARSE_SETTINGS_ENUM(list,

menu/menu_setting.c

@@ -5177,6 +5177,31 @@ static void setting_get_string_representation_uint_video_dingux_ipu_filter_type(
          break;
    }
 }
+#if defined(DINGUX_BETA)
+static void setting_get_string_representation_uint_video_dingux_refresh_rate(
+      rarch_setting_t *setting,
+      char *s, size_t len)
+{
+   if (!setting)
+      return;
+
+   switch (*setting->value.target.unsigned_integer)
+   {
+      case DINGUX_REFRESH_RATE_60HZ:
+         strlcpy(s,
+               msg_hash_to_str(
+                  MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_REFRESH_RATE_60HZ),
+               len);
+         break;
+      case DINGUX_REFRESH_RATE_50HZ:
+         strlcpy(s,
+               msg_hash_to_str(
+                  MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_REFRESH_RATE_50HZ),
+               len);
+         break;
+   }
+}
+#endif
 #endif
 
 static void setting_get_string_representation_uint_input_auto_game_focus(
@@ -7249,6 +7274,46 @@ static void general_write_handler(rarch_setting_t *setting)
          /* In case refresh rate update forced non-block video. */
          rarch_cmd = CMD_EVENT_VIDEO_SET_BLOCKING_STATE;
          break;
+#if defined(DINGUX) && defined(DINGUX_BETA)
+      case MENU_ENUM_LABEL_VIDEO_DINGUX_REFRESH_RATE:
+         {
+            enum dingux_refresh_rate current_refresh_rate = DINGUX_REFRESH_RATE_60HZ;
+            enum dingux_refresh_rate target_refresh_rate  =
+                  (enum dingux_refresh_rate)settings->uints.video_dingux_refresh_rate;
+            bool refresh_rate_valid                       = false;
+
+            /* Get current refresh rate */
+            refresh_rate_valid = dingux_get_video_refresh_rate(&current_refresh_rate);
+
+            /* Check if refresh rate has changed */
+            if (!refresh_rate_valid ||
+                (current_refresh_rate != target_refresh_rate))
+            {
+               /* Get floating point representation of
+                * new refresh rate */
+               float hw_refresh_rate = 60.0f;
+
+               switch (target_refresh_rate)
+               {
+                  case DINGUX_REFRESH_RATE_50HZ:
+                     hw_refresh_rate = 50.0f;
+                  default:
+                     break;
+               }
+
+               /* Manually update 'settings->floats.video_refresh_rate'
+                * (required for correct timing adjustments when
+                * reinitialising drivers) */
+               configuration_set_float(settings,
+                     settings->floats.video_refresh_rate,
+                     hw_refresh_rate);
+
+               /* Trigger driver reinitialisation */
+               rarch_cmd = CMD_EVENT_REINIT;
+            }
+         }
+         break;
+#endif
       case MENU_ENUM_LABEL_VIDEO_SCALE:
          settings->modified           = true;
          settings->floats.video_scale = roundf(*setting->value.target.fraction);
@@ -10528,42 +10593,65 @@ static bool setting_append_list(
                SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_ADVANCED);
             }
 
-            CONFIG_FLOAT(
+#if defined(DINGUX) && defined(DINGUX_BETA)
-                  list, list_info,
+            if (string_is_equal(settings->arrays.video_driver, "sdl_dingux"))
-                  &settings->floats.video_refresh_rate,
+            {
-                  MENU_ENUM_LABEL_VIDEO_REFRESH_RATE,
+               CONFIG_UINT(
-                  MENU_ENUM_LABEL_VALUE_VIDEO_REFRESH_RATE,
+                     list, list_info,
-                  DEFAULT_REFRESH_RATE,
+                     &settings->uints.video_dingux_refresh_rate,
-                  "%.3f Hz",
+                     MENU_ENUM_LABEL_VIDEO_DINGUX_REFRESH_RATE,
-                  &group_info,
+                     MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_REFRESH_RATE,
-                  &subgroup_info,
+                     DEFAULT_DINGUX_REFRESH_RATE,
-                  parent_group,
+                     &group_info,
-                  general_write_handler,
+                     &subgroup_info,
-                  general_read_handler);
+                     parent_group,
-            menu_settings_list_current_add_range(list, list_info, 0, 0, 0.001, true, false);
+                     general_write_handler,
-            SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
+                     general_read_handler);
-
+               (*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
-            CONFIG_FLOAT(
+               (*list)[list_info->index - 1].get_string_representation =
-                  list, list_info,
+                     &setting_get_string_representation_uint_video_dingux_refresh_rate;
-                  &settings->floats.video_refresh_rate,
+               menu_settings_list_current_add_range(list, list_info, 0, DINGUX_REFRESH_RATE_LAST - 1, 1, true, true);
-                  MENU_ENUM_LABEL_VIDEO_REFRESH_RATE_AUTO,
+               (*list)[list_info->index - 1].ui_type   = ST_UI_TYPE_UINT_COMBOBOX;
-                  MENU_ENUM_LABEL_VALUE_VIDEO_REFRESH_RATE_AUTO,
+            }
-                  DEFAULT_REFRESH_RATE,
+            else
-                  "%.3f Hz",
+#endif
-                  &group_info,
-                  &subgroup_info,
-                  parent_group,
-                  general_write_handler,
-                  general_read_handler);
-            (*list)[list_info->index - 1].action_start  = &setting_action_start_video_refresh_rate_auto;
-            (*list)[list_info->index - 1].action_ok     = &setting_action_ok_video_refresh_rate_auto;
-            (*list)[list_info->index - 1].action_select = &setting_action_ok_video_refresh_rate_auto;
-            (*list)[list_info->index - 1].get_string_representation =
-               &setting_get_string_representation_st_float_video_refresh_rate_auto;
-            SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
-
             {
                float actual_refresh_rate = video_driver_get_refresh_rate();
+
+               CONFIG_FLOAT(
+                     list, list_info,
+                     &settings->floats.video_refresh_rate,
+                     MENU_ENUM_LABEL_VIDEO_REFRESH_RATE,
+                     MENU_ENUM_LABEL_VALUE_VIDEO_REFRESH_RATE,
+                     DEFAULT_REFRESH_RATE,
+                     "%.3f Hz",
+                     &group_info,
+                     &subgroup_info,
+                     parent_group,
+                     general_write_handler,
+                     general_read_handler);
+               menu_settings_list_current_add_range(list, list_info, 0, 0, 0.001, true, false);
+               SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
+
+               CONFIG_FLOAT(
+                     list, list_info,
+                     &settings->floats.video_refresh_rate,
+                     MENU_ENUM_LABEL_VIDEO_REFRESH_RATE_AUTO,
+                     MENU_ENUM_LABEL_VALUE_VIDEO_REFRESH_RATE_AUTO,
+                     DEFAULT_REFRESH_RATE,
+                     "%.3f Hz",
+                     &group_info,
+                     &subgroup_info,
+                     parent_group,
+                     general_write_handler,
+                     general_read_handler);
+               (*list)[list_info->index - 1].action_start  = &setting_action_start_video_refresh_rate_auto;
+               (*list)[list_info->index - 1].action_ok     = &setting_action_ok_video_refresh_rate_auto;
+               (*list)[list_info->index - 1].action_select = &setting_action_ok_video_refresh_rate_auto;
+               (*list)[list_info->index - 1].get_string_representation =
+                  &setting_get_string_representation_st_float_video_refresh_rate_auto;
+               SETTINGS_DATA_LIST_CURRENT_ADD_FLAGS(list, list_info, SD_FLAG_LAKKA_ADVANCED);
+
                if (actual_refresh_rate > 0.0)
                {
                   CONFIG_FLOAT(

msg_hash.h

@@ -2427,6 +2427,12 @@ enum msg_hash_enums
    MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_IPU_FILTER_BICUBIC,
    MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_IPU_FILTER_BILINEAR,
    MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_IPU_FILTER_NEAREST,
+#if defined(DINGUX_BETA)
+   MENU_LABEL(VIDEO_DINGUX_REFRESH_RATE),
+
+   MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_REFRESH_RATE_60HZ,
+   MENU_ENUM_LABEL_VALUE_VIDEO_DINGUX_REFRESH_RATE_50HZ,
+#endif
 #endif
    MENU_LABEL(VIDEO_VFILTER),
    MENU_LABEL(VIDEO_GPU_RECORD),