Settings: Force Frame Timings => Force Video Timing

Also drop from GameDB, an override doesn't make sense here anyway,
due to the low success rate with the enhancement.

src/core/fullscreen_ui.cpp

@@ -4270,11 +4270,11 @@ void FullscreenUI::DrawDisplaySettingsPage()
     "Display", "Scaling", Settings::DEFAULT_DISPLAY_SCALING, &Settings::ParseDisplayScaling,
     &Settings::GetDisplayScalingName, &Settings::GetDisplayScalingDisplayName, DisplayScalingMode::Count);
 
-  DrawEnumSetting(
+  DrawEnumSetting(bsi, FSUI_CSTR("Force Video Timing"),
-    bsi, FSUI_CSTR("Force Frame Timings"),
+                  FSUI_CSTR("Utilizes the chosen video timing regardless of the game's setting."), "GPU",
-    FSUI_CSTR("Utilizes the chosen frame timing regardless of the active region."),
+                  "ForceVideoTiming", Settings::DEFAULT_FORCE_VIDEO_TIMING_MODE, &Settings::ParseForceVideoTimingName,
-    "GPU", "ForceFrameTimings", Settings::DEFAULT_FORCE_FRAME_TIMINGS_MODE, &Settings::ParseForceFrameTimings,
+                  &Settings::GetForceVideoTimingName, &Settings::GetForceVideoTimingDisplayName,
-    &Settings::GetForceFrameTimingsName, &Settings::GetForceFrameTimingsDisplayName, ForceFrameTimingsMode::Count);
+                  ForceVideoTimingMode::Count);
 
   if (is_hardware)
   {
@@ -5698,7 +5698,6 @@ void FullscreenUI::DrawSaveStateSelector(bool is_loading)
   if (IsFocusResetFromWindowChange())
     ImGui::SetNextWindowScroll(ImVec2(0.0f, 0.0f));
 
-
   if (ImGui::BeginChild("state_list",
                         ImVec2(io.DisplaySize.x, io.DisplaySize.y - LayoutScale(LAYOUT_FOOTER_HEIGHT) - heading_size.y),
                         false, ImGuiWindowFlags_NavFlattened))
@@ -7434,8 +7433,7 @@ TRANSLATE_NOOP("FullscreenUI", "File Size");
 TRANSLATE_NOOP("FullscreenUI", "File Size: %.2f MB");
 TRANSLATE_NOOP("FullscreenUI", "File Title");
 TRANSLATE_NOOP("FullscreenUI", "Force 4:3 For FMVs");
-TRANSLATE_NOOP("FullscreenUI", "Force NTSC Timings");
+TRANSLATE_NOOP("FullscreenUI", "Force Video Timing");
-TRANSLATE_NOOP("FullscreenUI", "Forces PAL games to run at NTSC timings, i.e. 60hz. Some PAL games will run at their \"normal\" speeds, while others will break.");
 TRANSLATE_NOOP("FullscreenUI", "Forces a full rescan of all games previously identified.");
 TRANSLATE_NOOP("FullscreenUI", "Forces blending to be done in the shader at 16-bit precision, when not using true color. Non-trivial performance impact, and unnecessary for most games.");
 TRANSLATE_NOOP("FullscreenUI", "Forces the use of FIFO over Mailbox presentation, i.e. double buffering instead of triple buffering. Usually results in worse frame pacing.");
@@ -7809,7 +7807,9 @@ TRANSLATE_NOOP("FullscreenUI", "Uses native resolution coordinates for 2D polygo
 TRANSLATE_NOOP("FullscreenUI", "Uses perspective-correct interpolation for colors, which can improve visuals in some games.");
 TRANSLATE_NOOP("FullscreenUI", "Uses perspective-correct interpolation for texture coordinates, straightening out warped textures.");
 TRANSLATE_NOOP("FullscreenUI", "Uses screen positions to resolve PGXP data. May improve visuals in some games.");
+TRANSLATE_NOOP("FullscreenUI", "Utilizes the chosen video timing regardless of the game's setting.");
 TRANSLATE_NOOP("FullscreenUI", "Value: {} | Default: {} | Minimum: {} | Maximum: {}");
+TRANSLATE_NOOP("FullscreenUI", "Version: %s");
 TRANSLATE_NOOP("FullscreenUI", "Vertex Cache");
 TRANSLATE_NOOP("FullscreenUI", "Vertical Sync (VSync)");
 TRANSLATE_NOOP("FullscreenUI", "WARNING: Your game is still saving to the memory card. Continuing to {0} may IRREVERSIBLY DESTROY YOUR MEMORY CARD. We recommend resuming your game and waiting 5 seconds for it to finish saving.\n\nDo you want to {0} anyway?");
@@ -7836,6 +7836,5 @@ TRANSLATE_NOOP("FullscreenUI", "{} Frames");
 TRANSLATE_NOOP("FullscreenUI", "{} deleted.");
 TRANSLATE_NOOP("FullscreenUI", "{} does not exist.");
 TRANSLATE_NOOP("FullscreenUI", "{} is not a valid disc image.");
-TRANSLATE_NOOP("FullscreenUI", "Version: %s");
 // TRANSLATION-STRING-AREA-END
 #endif

src/core/game_database.cpp

@@ -38,7 +38,7 @@ namespace GameDatabase {
 enum : u32
 {
   GAME_DATABASE_CACHE_SIGNATURE = 0x45434C48,
-  GAME_DATABASE_CACHE_VERSION = 14,
+  GAME_DATABASE_CACHE_VERSION = 15,
 };
 
 static Entry* GetMutableEntry(std::string_view serial);
@@ -76,7 +76,6 @@ static constexpr const std::array<const char*, static_cast<u32>(GameDatabase::Tr
   "DisableTextureFiltering",
   "DisableSpriteTextureFiltering",
   "DisableScaledDithering",
-  "DisableForceFrameTimings",
   "DisableWidescreen",
   "DisablePGXP",
   "DisablePGXPCulling",
@@ -106,7 +105,6 @@ static constexpr const std::array<const char*, static_cast<u32>(GameDatabase::Tr
   TRANSLATE_NOOP("GameDatabase", "Disable Texture Filtering"),
   TRANSLATE_NOOP("GameDatabase", "Disable Sprite Texture Filtering"),
   TRANSLATE_NOOP("GameDatabase", "Disable Scaled Dithering"),
-  TRANSLATE_NOOP("GameDatabase", "Disable Force Frame Timings"),
   TRANSLATE_NOOP("GameDatabase", "Disable Widescreen"),
   TRANSLATE_NOOP("GameDatabase", "Disable PGXP"),
   TRANSLATE_NOOP("GameDatabase", "Disable PGXP Culling"),
@@ -591,14 +589,6 @@ void GameDatabase::Entry::ApplySettings(Settings& settings, bool display_osd_mes
     settings.gpu_widescreen_hack = false;
   }
 
-  if (HasTrait(Trait::DisableForceFrameTimings))
-  {
-    if (display_osd_messages && settings.gpu_force_frame_timings != ForceFrameTimingsMode::Disabled)
-      APPEND_MESSAGE(TRANSLATE_SV("GameDatabase", "Force frame timings disabled."));
-
-    settings.gpu_force_frame_timings = ForceFrameTimingsMode::Disabled;
-  }
-
   if (HasTrait(Trait::DisablePGXP))
   {
     if (display_osd_messages && settings.gpu_pgxp_enable)

src/core/game_database.h

@@ -40,7 +40,6 @@ enum class Trait : u32
   DisableTextureFiltering,
   DisableSpriteTextureFiltering,
   DisableScaledDithering,
-  DisableForceFrameTimings,
   DisableWidescreen,
   DisablePGXP,
   DisablePGXPCulling,

src/core/gpu.cpp

@@ -88,7 +88,7 @@ GPU::~GPU()
 bool GPU::Initialize()
 {
   m_force_progressive_scan = g_settings.gpu_disable_interlacing;
-  m_force_frame_timings = g_settings.gpu_force_frame_timings;
+  m_force_frame_timings = g_settings.gpu_force_video_timing;
   s_crtc_tick_event.Activate();
   m_fifo_size = g_settings.gpu_fifo_size;
   m_max_run_ahead = g_settings.gpu_max_run_ahead;
@@ -119,9 +119,9 @@ void GPU::UpdateSettings(const Settings& old_settings)
   m_fifo_size = g_settings.gpu_fifo_size;
   m_max_run_ahead = g_settings.gpu_max_run_ahead;
 
-  if (m_force_frame_timings != g_settings.gpu_force_frame_timings)
+  if (m_force_frame_timings != g_settings.gpu_force_video_timing)
   {
-    m_force_frame_timings = g_settings.gpu_force_frame_timings;
+    m_force_frame_timings = g_settings.gpu_force_video_timing;
     m_console_is_pal = System::IsPALRegion();
     UpdateCRTCConfig();
   }
@@ -637,7 +637,7 @@ void GPU::UpdateCRTCConfig()
   cs.vertical_display_start = std::min<u16>(cs.regs.Y1, cs.vertical_total);
   cs.vertical_display_end = std::min<u16>(cs.regs.Y2, cs.vertical_total);
 
-  if (m_GPUSTAT.pal_mode && m_force_frame_timings == ForceFrameTimingsMode::NTSC)
+  if (m_GPUSTAT.pal_mode && m_force_frame_timings == ForceVideoTimingMode::NTSC)
   {
     // scale to NTSC parameters
     cs.horizontal_display_start =
@@ -655,7 +655,7 @@ void GPU::UpdateCRTCConfig()
     cs.horizontal_total = NTSC_TICKS_PER_LINE;
     cs.current_tick_in_scanline %= NTSC_TICKS_PER_LINE;
   }
-  else if (!m_GPUSTAT.pal_mode && m_force_frame_timings == ForceFrameTimingsMode::PAL)
+  else if (!m_GPUSTAT.pal_mode && m_force_frame_timings == ForceVideoTimingMode::PAL)
   {
     // scale to PAL parameters
     cs.horizontal_display_start =

src/core/gpu.h

@@ -505,7 +505,7 @@ protected:
   bool m_set_texture_disable_mask = false;
   bool m_drawing_area_changed = false;
   bool m_force_progressive_scan = false;
-  ForceFrameTimingsMode m_force_frame_timings = ForceFrameTimingsMode::Disabled;
+  ForceVideoTimingMode m_force_frame_timings = ForceVideoTimingMode::Disabled;
 
   struct CRTCState
   {

src/core/imgui_overlays.cpp

@@ -444,9 +444,9 @@ void ImGuiManager::DrawEnhancementsOverlay()
   }
   if (g_settings.gpu_disable_interlacing)
     text.append(" ForceProg");
-  if (g_settings.gpu_force_frame_timings == ForceFrameTimingsMode::NTSC && System::GetRegion() == ConsoleRegion::PAL)
+  if (g_settings.gpu_force_video_timing == ForceVideoTimingMode::NTSC && System::GetRegion() == ConsoleRegion::PAL)
     text.append(" PAL60");
-  if (g_settings.gpu_force_frame_timings == ForceFrameTimingsMode::PAL && System::GetRegion() != ConsoleRegion::PAL)
+  if (g_settings.gpu_force_video_timing == ForceVideoTimingMode::PAL && System::GetRegion() != ConsoleRegion::PAL)
     text.append(" NTSC50");
   if (g_settings.gpu_texture_filter != GPUTextureFilter::Nearest)
   {

src/core/settings.cpp

@@ -231,10 +231,10 @@ void Settings::Load(SettingsInterface& si, SettingsInterface& controller_si)
       si.GetStringValue("GPU", "WireframeMode", GetGPUWireframeModeName(DEFAULT_GPU_WIREFRAME_MODE)).c_str())
       .value_or(DEFAULT_GPU_WIREFRAME_MODE);
   gpu_disable_interlacing = si.GetBoolValue("GPU", "DisableInterlacing", true);
-  gpu_force_frame_timings =
+  gpu_force_video_timing =
-    ParseForceFrameTimings(
+    ParseForceVideoTimingName(
-      si.GetStringValue("GPU", "ForceFrameTimings", GetForceFrameTimingsName(DEFAULT_FORCE_FRAME_TIMINGS_MODE)).c_str())
+      si.GetStringValue("GPU", "ForceVideoTiming", GetForceVideoTimingName(DEFAULT_FORCE_VIDEO_TIMING_MODE)).c_str())
-      .value_or(DEFAULT_FORCE_FRAME_TIMINGS_MODE);
+      .value_or(DEFAULT_FORCE_VIDEO_TIMING_MODE);
   gpu_widescreen_hack = si.GetBoolValue("GPU", "WidescreenHack", false);
   display_24bit_chroma_smoothing = si.GetBoolValue("GPU", "ChromaSmoothing24Bit", false);
   gpu_pgxp_enable = si.GetBoolValue("GPU", "PGXPEnable", false);
@@ -540,7 +540,7 @@ void Settings::Save(SettingsInterface& si, bool ignore_base) const
   si.SetUIntValue("GPU", "DownsampleScale", gpu_downsample_scale);
   si.SetStringValue("GPU", "WireframeMode", GetGPUWireframeModeName(gpu_wireframe_mode));
   si.SetBoolValue("GPU", "DisableInterlacing", gpu_disable_interlacing);
-  si.SetStringValue("GPU", "ForceFrameTimings", GetForceFrameTimingsName(gpu_force_frame_timings));
+  si.SetStringValue("GPU", "ForceVideoTiming", GetForceVideoTimingName(gpu_force_video_timing));
   si.SetBoolValue("GPU", "WidescreenHack", gpu_widescreen_hack);
   si.SetBoolValue("GPU", "ChromaSmoothing24Bit", display_24bit_chroma_smoothing);
   si.SetBoolValue("GPU", "PGXPEnable", gpu_pgxp_enable);
@@ -749,7 +749,7 @@ void Settings::FixIncompatibleSettings(bool display_osd_messages)
     g_settings.gpu_sprite_texture_filter = GPUTextureFilter::Nearest;
     g_settings.gpu_line_detect_mode = GPULineDetectMode::Disabled;
     g_settings.gpu_disable_interlacing = false;
-    g_settings.gpu_force_frame_timings = ForceFrameTimingsMode::Disabled;
+    g_settings.gpu_force_video_timing = ForceVideoTimingMode::Disabled;
     g_settings.gpu_widescreen_hack = false;
     g_settings.gpu_pgxp_enable = false;
     g_settings.display_24bit_chroma_smoothing = false;
@@ -933,12 +933,12 @@ std::optional<LOGLEVEL> Settings::ParseLogLevelName(const char* str)
 
 const char* Settings::GetLogLevelName(LOGLEVEL level)
 {
-  return s_log_level_names[static_cast<int>(level)];
+  return s_log_level_names[static_cast<size_t>(level)];
 }
 
 const char* Settings::GetLogLevelDisplayName(LOGLEVEL level)
 {
-  return Host::TranslateToCString("LogLevel", s_log_level_display_names[static_cast<int>(level)]);
+  return Host::TranslateToCString("LogLevel", s_log_level_display_names[static_cast<size_t>(level)]);
 }
 
 static constexpr const std::array s_console_region_names = {"Auto", "NTSC-J", "NTSC-U", "PAL"};
@@ -962,12 +962,12 @@ std::optional<ConsoleRegion> Settings::ParseConsoleRegionName(const char* str)
 
 const char* Settings::GetConsoleRegionName(ConsoleRegion region)
 {
-  return s_console_region_names[static_cast<int>(region)];
+  return s_console_region_names[static_cast<size_t>(region)];
 }
 
 const char* Settings::GetConsoleRegionDisplayName(ConsoleRegion region)
 {
-  return Host::TranslateToCString("ConsoleRegion", s_console_region_display_names[static_cast<int>(region)]);
+  return Host::TranslateToCString("ConsoleRegion", s_console_region_display_names[static_cast<size_t>(region)]);
 }
 
 static constexpr const std::array s_disc_region_names = {"NTSC-J", "NTSC-U", "PAL", "Other", "Non-PS1"};
@@ -992,12 +992,12 @@ std::optional<DiscRegion> Settings::ParseDiscRegionName(const char* str)
 
 const char* Settings::GetDiscRegionName(DiscRegion region)
 {
-  return s_disc_region_names[static_cast<int>(region)];
+  return s_disc_region_names[static_cast<size_t>(region)];
 }
 
 const char* Settings::GetDiscRegionDisplayName(DiscRegion region)
 {
-  return Host::TranslateToCString("DiscRegion", s_disc_region_display_names[static_cast<int>(region)]);
+  return Host::TranslateToCString("DiscRegion", s_disc_region_display_names[static_cast<size_t>(region)]);
 }
 
 static constexpr const std::array s_cpu_execution_mode_names = {"Interpreter", "CachedInterpreter", "Recompiler",
@@ -1111,12 +1111,12 @@ std::optional<GPURenderer> Settings::ParseRendererName(const char* str)
 
 const char* Settings::GetRendererName(GPURenderer renderer)
 {
-  return s_gpu_renderer_names[static_cast<int>(renderer)];
+  return s_gpu_renderer_names[static_cast<size_t>(renderer)];
 }
 
 const char* Settings::GetRendererDisplayName(GPURenderer renderer)
 {
-  return Host::TranslateToCString("GPURenderer", s_gpu_renderer_display_names[static_cast<int>(renderer)]);
+  return Host::TranslateToCString("GPURenderer", s_gpu_renderer_display_names[static_cast<size_t>(renderer)]);
 }
 
 RenderAPI Settings::GetRenderAPIForRenderer(GPURenderer renderer)
@@ -1219,7 +1219,7 @@ const char* Settings::GetTextureFilterName(GPUTextureFilter filter)
 
 const char* Settings::GetTextureFilterDisplayName(GPUTextureFilter filter)
 {
-  return Host::TranslateToCString("GPUTextureFilter", s_texture_filter_display_names[static_cast<int>(filter)]);
+  return Host::TranslateToCString("GPUTextureFilter", s_texture_filter_display_names[static_cast<size_t>(filter)]);
 }
 
 static constexpr const std::array s_line_detect_mode_names = {
@@ -1281,12 +1281,12 @@ std::optional<GPUDownsampleMode> Settings::ParseDownsampleModeName(const char* s
 
 const char* Settings::GetDownsampleModeName(GPUDownsampleMode mode)
 {
-  return s_downsample_mode_names[static_cast<int>(mode)];
+  return s_downsample_mode_names[static_cast<size_t>(mode)];
 }
 
 const char* Settings::GetDownsampleModeDisplayName(GPUDownsampleMode mode)
 {
-  return Host::TranslateToCString("GPUDownsampleMode", s_downsample_mode_display_names[static_cast<int>(mode)]);
+  return Host::TranslateToCString("GPUDownsampleMode", s_downsample_mode_display_names[static_cast<size_t>(mode)]);
 }
 
 static constexpr const std::array s_wireframe_mode_names = {"Disabled", "OverlayWireframe", "OnlyWireframe"};
@@ -1310,12 +1310,12 @@ std::optional<GPUWireframeMode> Settings::ParseGPUWireframeMode(const char* str)
 
 const char* Settings::GetGPUWireframeModeName(GPUWireframeMode mode)
 {
-  return s_wireframe_mode_names[static_cast<int>(mode)];
+  return s_wireframe_mode_names[static_cast<size_t>(mode)];
 }
 
 const char* Settings::GetGPUWireframeModeDisplayName(GPUWireframeMode mode)
 {
-  return Host::TranslateToCString("GPUWireframeMode", s_wireframe_mode_display_names[static_cast<int>(mode)]);
+  return Host::TranslateToCString("GPUWireframeMode", s_wireframe_mode_display_names[static_cast<size_t>(mode)]);
 }
 
 static constexpr const std::array s_display_deinterlacing_mode_names = {
@@ -1347,13 +1347,13 @@ std::optional<DisplayDeinterlacingMode> Settings::ParseDisplayDeinterlacingMode(
 
 const char* Settings::GetDisplayDeinterlacingModeName(DisplayDeinterlacingMode mode)
 {
-  return s_display_deinterlacing_mode_names[static_cast<int>(mode)];
+  return s_display_deinterlacing_mode_names[static_cast<size_t>(mode)];
 }
 
 const char* Settings::GetDisplayDeinterlacingModeDisplayName(DisplayDeinterlacingMode mode)
 {
   return Host::TranslateToCString("DisplayDeinterlacingMode",
-                                  s_display_deinterlacing_mode_display_names[static_cast<int>(mode)]);
+                                  s_display_deinterlacing_mode_display_names[static_cast<size_t>(mode)]);
 }
 
 static constexpr const std::array s_display_crop_mode_names = {"None", "Overscan", "Borders"};
@@ -1377,12 +1377,12 @@ std::optional<DisplayCropMode> Settings::ParseDisplayCropMode(const char* str)
 
 const char* Settings::GetDisplayCropModeName(DisplayCropMode crop_mode)
 {
-  return s_display_crop_mode_names[static_cast<int>(crop_mode)];
+  return s_display_crop_mode_names[static_cast<size_t>(crop_mode)];
 }
 
 const char* Settings::GetDisplayCropModeDisplayName(DisplayCropMode crop_mode)
 {
-  return Host::TranslateToCString("DisplayCropMode", s_display_crop_mode_display_names[static_cast<int>(crop_mode)]);
+  return Host::TranslateToCString("DisplayCropMode", s_display_crop_mode_display_names[static_cast<size_t>(crop_mode)]);
 }
 
 static constexpr const std::array s_display_aspect_ratio_names = {
@@ -1419,12 +1419,12 @@ std::optional<DisplayAspectRatio> Settings::ParseDisplayAspectRatio(const char*
 
 const char* Settings::GetDisplayAspectRatioName(DisplayAspectRatio ar)
 {
-  return s_display_aspect_ratio_names[static_cast<int>(ar)];
+  return s_display_aspect_ratio_names[static_cast<size_t>(ar)];
 }
 
 const char* Settings::GetDisplayAspectRatioDisplayName(DisplayAspectRatio ar)
 {
-  return Host::TranslateToCString("DisplayAspectRatio", s_display_aspect_ratio_names[static_cast<int>(ar)]);
+  return Host::TranslateToCString("DisplayAspectRatio", s_display_aspect_ratio_names[static_cast<size_t>(ar)]);
 }
 
 float Settings::GetDisplayAspectRatioValue() const
@@ -1434,7 +1434,7 @@ float Settings::GetDisplayAspectRatioValue() const
     case DisplayAspectRatio::MatchWindow:
     {
       if (!g_gpu_device)
-        return s_display_aspect_ratio_values[static_cast<int>(DEFAULT_DISPLAY_ASPECT_RATIO)];
+        return s_display_aspect_ratio_values[static_cast<size_t>(DEFAULT_DISPLAY_ASPECT_RATIO)];
 
       return static_cast<float>(g_gpu_device->GetWindowWidth()) / static_cast<float>(g_gpu_device->GetWindowHeight());
     }
@@ -1447,7 +1447,7 @@ float Settings::GetDisplayAspectRatioValue() const
 
     default:
     {
-      return s_display_aspect_ratio_values[static_cast<int>(display_aspect_ratio)];
+      return s_display_aspect_ratio_values[static_cast<size_t>(display_aspect_ratio)];
     }
   }
 }
@@ -1473,12 +1473,13 @@ std::optional<DisplayAlignment> Settings::ParseDisplayAlignment(const char* str)
 
 const char* Settings::GetDisplayAlignmentName(DisplayAlignment alignment)
 {
-  return s_display_alignment_names[static_cast<int>(alignment)];
+  return s_display_alignment_names[static_cast<size_t>(alignment)];
 }
 
 const char* Settings::GetDisplayAlignmentDisplayName(DisplayAlignment alignment)
 {
-  return Host::TranslateToCString("DisplayAlignment", s_display_alignment_display_names[static_cast<int>(alignment)]);
+  return Host::TranslateToCString("DisplayAlignment",
+                                  s_display_alignment_display_names[static_cast<size_t>(alignment)]);
 }
 
 static constexpr const std::array s_display_rotation_names = {"Normal", "Rotate90", "Rotate180", "Rotate270"};
@@ -1505,29 +1506,44 @@ std::optional<DisplayRotation> Settings::ParseDisplayRotation(const char* str)
 
 const char* Settings::GetDisplayRotationName(DisplayRotation rotation)
 {
-  return s_display_rotation_names[static_cast<int>(rotation)];
+  return s_display_rotation_names[static_cast<size_t>(rotation)];
 }
 
 const char* Settings::GetDisplayRotationDisplayName(DisplayRotation rotation)
 {
   return Host::TranslateToCString("Settings", s_display_rotation_display_names[static_cast<size_t>(rotation)]);
 }
-static constexpr const std::array s_display_force_frame_timings_names = {
+
-  "Disabled", "NTSC", "PAL"
+static constexpr const std::array s_display_force_video_timings_names = {
+  TRANSLATE_NOOP("Settings", "Disabled"),
+  "NTSC",
+  "PAL",
 };
-std::optional<ForceFrameTimingsMode> Settings::ParseForceFrameTimings(const char* str)
+
+std::optional<ForceVideoTimingMode> Settings::ParseForceVideoTimingName(const char* str)
 {
   int index = 0;
-  for (const char* name : s_display_force_frame_timings_names)
+  for (const char* name : s_display_force_video_timings_names)
   {
     if (StringUtil::Strcasecmp(name, str) == 0)
-      return static_cast<ForceFrameTimingsMode>(index);
+      return static_cast<ForceVideoTimingMode>(index);
 
     index++;
   }
 
   return std::nullopt;
 }
+
+const char* Settings::GetForceVideoTimingName(ForceVideoTimingMode mode)
+{
+  return s_display_force_video_timings_names[static_cast<size_t>(mode)];
+}
+
+const char* Settings::GetForceVideoTimingDisplayName(ForceVideoTimingMode mode)
+{
+  return Host::TranslateToCString("Settings", s_display_force_video_timings_names[static_cast<size_t>(mode)]);
+}
+
 static constexpr const std::array s_display_scaling_names = {
   "Nearest", "NearestInteger", "BilinearSmooth", "BilinearSharp", "BilinearInteger",
 };
@@ -1555,22 +1571,12 @@ std::optional<DisplayScalingMode> Settings::ParseDisplayScaling(const char* str)
 
 const char* Settings::GetDisplayScalingName(DisplayScalingMode mode)
 {
-  return s_display_scaling_names[static_cast<int>(mode)];
+  return s_display_scaling_names[static_cast<size_t>(mode)];
 }
 
 const char* Settings::GetDisplayScalingDisplayName(DisplayScalingMode mode)
 {
-  return Host::TranslateToCString("DisplayScalingMode", s_display_scaling_display_names[static_cast<int>(mode)]);
+  return Host::TranslateToCString("DisplayScalingMode", s_display_scaling_display_names[static_cast<size_t>(mode)]);
-}
-
-const char* Settings::GetForceFrameTimingsName(ForceFrameTimingsMode mode)
-{
-  return s_display_force_frame_timings_names[static_cast<int>(mode)];
-}
-
-const char* Settings::GetForceFrameTimingsDisplayName(ForceFrameTimingsMode mode)
-{
-  return Host::TranslateToCString("ForceFrameTimingsMode", s_display_force_frame_timings_names[static_cast<int>(mode)]);
 }
 
 static constexpr const std::array s_display_exclusive_fullscreen_mode_names = {
@@ -1600,13 +1606,13 @@ std::optional<DisplayExclusiveFullscreenControl> Settings::ParseDisplayExclusive
 
 const char* Settings::GetDisplayExclusiveFullscreenControlName(DisplayExclusiveFullscreenControl mode)
 {
-  return s_display_exclusive_fullscreen_mode_names[static_cast<int>(mode)];
+  return s_display_exclusive_fullscreen_mode_names[static_cast<size_t>(mode)];
 }
 
 const char* Settings::GetDisplayExclusiveFullscreenControlDisplayName(DisplayExclusiveFullscreenControl mode)
 {
   return Host::TranslateToCString("Settings",
-                                  s_display_exclusive_fullscreen_mode_display_names[static_cast<int>(mode)]);
+                                  s_display_exclusive_fullscreen_mode_display_names[static_cast<size_t>(mode)]);
 }
 
 static constexpr const std::array s_display_screenshot_mode_names = {
@@ -1715,12 +1721,12 @@ std::optional<MemoryCardType> Settings::ParseMemoryCardTypeName(const char* str)
 
 const char* Settings::GetMemoryCardTypeName(MemoryCardType type)
 {
-  return s_memory_card_type_names[static_cast<int>(type)];
+  return s_memory_card_type_names[static_cast<size_t>(type)];
 }
 
 const char* Settings::GetMemoryCardTypeDisplayName(MemoryCardType type)
 {
-  return Host::TranslateToCString("MemoryCardType", s_memory_card_type_display_names[static_cast<int>(type)]);
+  return Host::TranslateToCString("MemoryCardType", s_memory_card_type_display_names[static_cast<size_t>(type)]);
 }
 
 std::string Settings::GetDefaultSharedMemoryCardName(u32 slot)

src/core/settings.h

@@ -132,7 +132,7 @@ struct Settings
   bool gpu_pgxp_preserve_proj_fp : 1 = false;
   bool gpu_pgxp_depth_buffer : 1 = false;
   bool gpu_pgxp_disable_2d : 1 = false;
-  ForceFrameTimingsMode gpu_force_frame_timings = DEFAULT_FORCE_FRAME_TIMINGS_MODE;
+  ForceVideoTimingMode gpu_force_video_timing = DEFAULT_FORCE_VIDEO_TIMING_MODE;
   GPUTextureFilter gpu_texture_filter = DEFAULT_GPU_TEXTURE_FILTER;
   GPUTextureFilter gpu_sprite_texture_filter = DEFAULT_GPU_TEXTURE_FILTER;
   GPULineDetectMode gpu_line_detect_mode = DEFAULT_GPU_LINE_DETECT_MODE;
@@ -434,9 +434,9 @@ struct Settings
   static const char* GetDisplayScalingName(DisplayScalingMode mode);
   static const char* GetDisplayScalingDisplayName(DisplayScalingMode mode);
 
-  static std::optional<ForceFrameTimingsMode> ParseForceFrameTimings(const char* str);
+  static std::optional<ForceVideoTimingMode> ParseForceVideoTimingName(const char* str);
-  static const char* GetForceFrameTimingsName(ForceFrameTimingsMode mode);
+  static const char* GetForceVideoTimingName(ForceVideoTimingMode mode);
-  static const char* GetForceFrameTimingsDisplayName(ForceFrameTimingsMode mode);
+  static const char* GetForceVideoTimingDisplayName(ForceVideoTimingMode mode);
 
   static std::optional<DisplayExclusiveFullscreenControl> ParseDisplayExclusiveFullscreenControl(const char* str);
   static const char* GetDisplayExclusiveFullscreenControlName(DisplayExclusiveFullscreenControl mode);
@@ -496,7 +496,7 @@ struct Settings
   static constexpr DisplayAlignment DEFAULT_DISPLAY_ALIGNMENT = DisplayAlignment::Center;
   static constexpr DisplayRotation DEFAULT_DISPLAY_ROTATION = DisplayRotation::Normal;
   static constexpr DisplayScalingMode DEFAULT_DISPLAY_SCALING = DisplayScalingMode::BilinearSmooth;
-  static constexpr ForceFrameTimingsMode DEFAULT_FORCE_FRAME_TIMINGS_MODE = ForceFrameTimingsMode::Disabled;
+  static constexpr ForceVideoTimingMode DEFAULT_FORCE_VIDEO_TIMING_MODE = ForceVideoTimingMode::Disabled;
   static constexpr DisplayExclusiveFullscreenControl DEFAULT_DISPLAY_EXCLUSIVE_FULLSCREEN_CONTROL =
     DisplayExclusiveFullscreenControl::Automatic;
   static constexpr DisplayScreenshotMode DEFAULT_DISPLAY_SCREENSHOT_MODE = DisplayScreenshotMode::ScreenResolution;

src/core/system.cpp

@@ -4304,7 +4304,7 @@ void System::CheckForSettingsChanges(const Settings& old_settings)
         g_settings.gpu_sprite_texture_filter != old_settings.gpu_sprite_texture_filter ||
         g_settings.gpu_line_detect_mode != old_settings.gpu_line_detect_mode ||
         g_settings.gpu_disable_interlacing != old_settings.gpu_disable_interlacing ||
-        g_settings.gpu_force_frame_timings != old_settings.gpu_force_frame_timings ||
+        g_settings.gpu_force_video_timing != old_settings.gpu_force_video_timing ||
         g_settings.gpu_downsample_mode != old_settings.gpu_downsample_mode ||
         g_settings.gpu_downsample_scale != old_settings.gpu_downsample_scale ||
         g_settings.gpu_wireframe_mode != old_settings.gpu_wireframe_mode ||
@@ -4531,7 +4531,7 @@ void System::WarnAboutUnsafeSettings()
                                         TinyString(TRANSLATE_SV("System", "Instant")) :
                                         TinyString::from_format("{}x", g_settings.cdrom_seek_speedup)));
     }
-    if (g_settings.gpu_force_frame_timings != ForceFrameTimingsMode::Disabled)
+    if (g_settings.gpu_force_video_timing != ForceVideoTimingMode::Disabled)
     {
       append(ICON_FA_TV, TRANSLATE_SV("System", "Force frame timings is enabled. Games may run at incorrect speeds."));
     }

src/core/types.h

@@ -276,7 +276,7 @@ enum class SaveStateCompressionMode : u8
   Count,
 };
 
-enum class ForceFrameTimingsMode : u8
+enum class ForceVideoTimingMode : u8
 {
   Disabled,
   NTSC,

src/duckstation-qt/graphicssettingswidget.cpp

@@ -74,9 +74,9 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* dialog, QWidget*
   SettingWidgetBinder::BindWidgetToEnumSetting(sif, m_ui.displayScaling, "Display", "Scaling",
                                                &Settings::ParseDisplayScaling, &Settings::GetDisplayScalingName,
                                                Settings::DEFAULT_DISPLAY_SCALING);
-  SettingWidgetBinder::BindWidgetToEnumSetting(sif, m_ui.forceFrameTimings, "GPU", "ForceFrameTimings",
+  SettingWidgetBinder::BindWidgetToEnumSetting(sif, m_ui.forceVideoTiming, "GPU", "ForceVideoTiming",
-                                               &Settings::ParseForceFrameTimings, &Settings::GetForceFrameTimingsName,
+                                               &Settings::ParseForceVideoTimingName, &Settings::GetForceVideoTimingName,
-                                               Settings::DEFAULT_FORCE_FRAME_TIMINGS_MODE);
+                                               Settings::DEFAULT_FORCE_VIDEO_TIMING_MODE);
   SettingWidgetBinder::BindWidgetToIntSetting(sif, m_ui.gpuDownsampleScale, "GPU", "DownsampleScale", 1);
   SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.trueColor, "GPU", "TrueColor", false);
   SettingWidgetBinder::BindWidgetToBoolSetting(sif, m_ui.disableInterlacing, "GPU", "DisableInterlacing", true);
@@ -108,8 +108,6 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* dialog, QWidget*
                                        !m_dialog->hasGameTrait(GameDatabase::Trait::ForceInterlacing));
   SettingWidgetBinder::SetAvailability(m_ui.widescreenHack,
                                        !m_dialog->hasGameTrait(GameDatabase::Trait::DisableWidescreen));
-  SettingWidgetBinder::SetAvailability(m_ui.forceFrameTimings,
-                                       !m_dialog->hasGameTrait(GameDatabase::Trait::DisableForceFrameTimings));
 
   // Advanced Tab
 
@@ -339,11 +337,11 @@ GraphicsSettingsWidget::GraphicsSettingsWidget(SettingsWindow* dialog, QWidget*
     m_ui.displayScaling, tr("Scaling"), tr("Bilinear (Smooth)"),
     tr("Determines how the emulated console's output is upscaled or downscaled to your monitor's resolution."));
   dialog->registerWidgetHelp(
-    m_ui.forceFrameTimings, tr("Force Frame Timings"), tr("Disabled"),
+    m_ui.forceVideoTiming, tr("Force Video Timing"), tr("Disabled"),
-    tr("Utilizes the chosen frame timing regardless of the active region. "
+    tr("Utilizes the chosen frame timing regardless of the active region. This feature can be used to force PAL games "
-       "This feature can be used to force PAL games to run at 60Hz and NTSC games to run at 50Hz. "
+       "to run at 60Hz and NTSC games to run at 50Hz. For most games which have a speed tied to the framerate, this "
-       "For most games which have a speed tied to the framerate, this will result in the game running approximately 17% faster or slower. "
+       "will result in the game running approximately 17% faster or slower. For variable frame rate games, it may not "
-       "For variable frame rate games, it may not affect the speed."));
+       "affect the speed."));
   dialog->registerWidgetHelp(
     m_ui.trueColor, tr("True Color Rendering"), tr("Checked"),
     tr("Forces the precision of colours output to the console's framebuffer to use the full 8 bits of precision per "
@@ -658,13 +656,12 @@ void GraphicsSettingsWidget::setupAdditionalUi()
       QString::fromUtf8(Settings::GetDisplayScalingDisplayName(static_cast<DisplayScalingMode>(i))));
   }
 
-  for (u32 i = 0; i < static_cast<u32>(ForceFrameTimingsMode::Count); i++)
+  for (u32 i = 0; i < static_cast<u32>(ForceVideoTimingMode::Count); i++)
   {
-    m_ui.forceFrameTimings->addItem(
+    m_ui.forceVideoTiming->addItem(
-      QString::fromUtf8(Settings::GetForceFrameTimingsName(static_cast<ForceFrameTimingsMode>(i))));
+      QString::fromUtf8(Settings::GetForceVideoTimingName(static_cast<ForceVideoTimingMode>(i))));
   }
 
-
   // Advanced Tab
 
   for (u32 i = 0; i < static_cast<u32>(DisplayExclusiveFullscreenControl::Count); i++)

src/duckstation-qt/graphicssettingswidget.ui

@@ -268,14 +268,14 @@
            <widget class="QComboBox" name="spriteTextureFiltering"/>
           </item>
           <item row="8" column="0">
-           <widget class="QLabel" name="forceFrameTimingsLabel">
+           <widget class="QLabel" name="forceVideoTimingLabel">
             <property name="text">
-             <string>Force Frame Timings:</string>
+             <string>Force Video Timing:</string>
             </property>
            </widget>
           </item>
           <item row="8" column="1">
-           <widget class="QComboBox" name="forceFrameTimings"/>
+           <widget class="QComboBox" name="forceVideoTiming"/>
           </item>
          </layout>
         </widget>