Merge pull request #10349 from AdmiralCurtiss/config-port-core-2

Config: Port remaining Core settings to new config system (part 2).

Source/Core/AudioCommon/Mixer.cpp

@@ -35,11 +35,15 @@ Mixer::Mixer(unsigned int BackendSampleRate)
       m_surround_decoder(BackendSampleRate,
                          DPL2QualityToFrameBlockSize(Config::Get(Config::MAIN_DPL2_QUALITY)))
 {
+  m_config_changed_callback_id = Config::AddConfigChangedCallback([this] { RefreshConfig(); });
+  RefreshConfig();
+
   INFO_LOG_FMT(AUDIO_INTERFACE, "Mixer is initialized");
 }
 
 Mixer::~Mixer()
 {
+  Config::RemoveConfigChangedCallback(m_config_changed_callback_id);
 }
 
 void Mixer::DoState(PointerWrap& p)
@@ -53,7 +57,8 @@ void Mixer::DoState(PointerWrap& p)
 
 // Executed from sound stream thread
 unsigned int Mixer::MixerFifo::Mix(short* samples, unsigned int numSamples,
-                                   bool consider_framelimit)
+                                   bool consider_framelimit, float emulationspeed,
+                                   int timing_variance)
 {
   unsigned int currentSample = 0;
 
@@ -71,13 +76,12 @@ unsigned int Mixer::MixerFifo::Mix(short* samples, unsigned int numSamples,
   // advance indexR with sample position
   // remember fractional offset
 
-  float emulationspeed = SConfig::GetInstance().m_EmulationSpeed;
   float aid_sample_rate = static_cast<float>(m_input_sample_rate);
   if (consider_framelimit && emulationspeed > 0.0f)
   {
     float numLeft = static_cast<float>(((indexW - indexR) & INDEX_MASK) / 2);
 
-    u32 low_waterwark = m_input_sample_rate * SConfig::GetInstance().iTimingVariance / 1000;
+    u32 low_waterwark = m_input_sample_rate * timing_variance / 1000;
     low_waterwark = std::min(low_waterwark, MAX_SAMPLES / 2);
 
     m_numLeftI = (numLeft + m_numLeftI * (CONTROL_AVG - 1)) / CONTROL_AVG;
@@ -154,18 +158,26 @@ unsigned int Mixer::Mix(short* samples, unsigned int num_samples)
 
   memset(samples, 0, num_samples * 2 * sizeof(short));
 
-  if (Config::Get(Config::MAIN_AUDIO_STRETCH))
+  const float emulation_speed = m_config_emulation_speed;
+  const int timing_variance = m_config_timing_variance;
+  if (m_config_audio_stretch)
   {
     unsigned int available_samples =
         std::min(m_dma_mixer.AvailableSamples(), m_streaming_mixer.AvailableSamples());
 
     m_scratch_buffer.fill(0);
 
-    m_dma_mixer.Mix(m_scratch_buffer.data(), available_samples, false);
-    m_streaming_mixer.Mix(m_scratch_buffer.data(), available_samples, false);
-    m_wiimote_speaker_mixer.Mix(m_scratch_buffer.data(), available_samples, false);
+    m_dma_mixer.Mix(m_scratch_buffer.data(), available_samples, false, emulation_speed,
+                    timing_variance);
+    m_streaming_mixer.Mix(m_scratch_buffer.data(), available_samples, false, emulation_speed,
+                          timing_variance);
+    m_wiimote_speaker_mixer.Mix(m_scratch_buffer.data(), available_samples, false, emulation_speed,
+                                timing_variance);
     for (auto& mixer : m_gba_mixers)
-      mixer.Mix(m_scratch_buffer.data(), available_samples, false);
+    {
+      mixer.Mix(m_scratch_buffer.data(), available_samples, false, emulation_speed,
+                timing_variance);
+    }
 
     if (!m_is_stretching)
     {
@@ -177,11 +189,11 @@ unsigned int Mixer::Mix(short* samples, unsigned int num_samples)
   }
   else
   {
-    m_dma_mixer.Mix(samples, num_samples, true);
-    m_streaming_mixer.Mix(samples, num_samples, true);
-    m_wiimote_speaker_mixer.Mix(samples, num_samples, true);
+    m_dma_mixer.Mix(samples, num_samples, true, emulation_speed, timing_variance);
+    m_streaming_mixer.Mix(samples, num_samples, true, emulation_speed, timing_variance);
+    m_wiimote_speaker_mixer.Mix(samples, num_samples, true, emulation_speed, timing_variance);
     for (auto& mixer : m_gba_mixers)
-      mixer.Mix(samples, num_samples, true);
+      mixer.Mix(samples, num_samples, true, emulation_speed, timing_variance);
     m_is_stretching = false;
   }
 
@@ -385,6 +397,13 @@ void Mixer::StopLogDSPAudio()
   }
 }
 
+void Mixer::RefreshConfig()
+{
+  m_config_emulation_speed = Config::Get(Config::MAIN_EMULATION_SPEED);
+  m_config_timing_variance = Config::Get(Config::MAIN_TIMING_VARIANCE);
+  m_config_audio_stretch = Config::Get(Config::MAIN_AUDIO_STRETCH);
+}
+
 void Mixer::MixerFifo::DoState(PointerWrap& p)
 {
   p.Do(m_input_sample_rate);

Source/Core/AudioCommon/Mixer.h

@@ -69,7 +69,8 @@ class Mixer final
     }
     void DoState(PointerWrap& p);
     void PushSamples(const short* samples, unsigned int num_samples);
-    unsigned int Mix(short* samples, unsigned int numSamples, bool consider_framelimit = true);
+    unsigned int Mix(short* samples, unsigned int numSamples, bool consider_framelimit,
+                     float emulationspeed, int timing_variance);
     void SetInputSampleRate(unsigned int rate);
     unsigned int GetInputSampleRate() const;
     void SetVolume(unsigned int lvolume, unsigned int rvolume);
@@ -89,6 +90,8 @@ class Mixer final
     u32 m_frac = 0;
   };
 
+  void RefreshConfig();
+
   MixerFifo m_dma_mixer{this, 32000, false};
   MixerFifo m_streaming_mixer{this, 48000, false};
   MixerFifo m_wiimote_speaker_mixer{this, 3000, true};
@@ -109,4 +112,10 @@ class Mixer final
 
   // Current rate of emulation (1.0 = 100% speed)
   std::atomic<float> m_speed{0.0f};
+
+  float m_config_emulation_speed;
+  int m_config_timing_variance;
+  bool m_config_audio_stretch;
+
+  size_t m_config_changed_callback_id;
 };

Source/Core/Core/BootManager.cpp

@@ -64,7 +64,6 @@ struct ConfigCache
 
   // These store if the relevant setting should be reset back later (true) or if it should be left
   // alone on restore (false)
-  bool bSetEmulationSpeed = false;
   bool bSetVolume = false;
   std::array<bool, MAX_BBMOTES> bSetWiimoteSource{};
   std::array<bool, SerialInterface::MAX_SI_CHANNELS> bSetPads{};
@@ -73,16 +72,11 @@ struct ConfigCache
 private:
   bool valid = false;
   bool bCPUThread = false;
-  bool bSyncGPUOnSkipIdleHack = false;
   bool bMMU = false;
-  bool bDisableICache = false;
   bool bSyncGPU = false;
   int iSyncGpuMaxDistance = 0;
   int iSyncGpuMinDistance = 0;
   float fSyncGpuOverclock = 0;
-  bool bFastDiscSpeed = false;
-  float m_EmulationSpeed = 0;
-  std::string m_strGPUDeterminismMode;
   std::array<WiimoteSource, MAX_BBMOTES> iWiimoteSource{};
   std::array<SerialInterface::SIDevices, SerialInterface::MAX_SI_CHANNELS> Pads{};
   std::array<ExpansionInterface::TEXIDevices, ExpansionInterface::MAX_EXI_CHANNELS> m_EXIDevice{};
@@ -93,24 +87,18 @@ void ConfigCache::SaveConfig(const SConfig& config)
   valid = true;
 
   bCPUThread = config.bCPUThread;
-  bSyncGPUOnSkipIdleHack = config.bSyncGPUOnSkipIdleHack;
-  bDisableICache = config.bDisableICache;
   bMMU = config.bMMU;
   bSyncGPU = config.bSyncGPU;
   iSyncGpuMaxDistance = config.iSyncGpuMaxDistance;
   iSyncGpuMinDistance = config.iSyncGpuMinDistance;
   fSyncGpuOverclock = config.fSyncGpuOverclock;
-  bFastDiscSpeed = config.bFastDiscSpeed;
-  m_EmulationSpeed = config.m_EmulationSpeed;
-  m_strGPUDeterminismMode = config.m_strGPUDeterminismMode;
 
   for (int i = 0; i != MAX_BBMOTES; ++i)
     iWiimoteSource[i] = WiimoteCommon::GetSource(i);
 
   std::copy(std::begin(config.m_SIDevice), std::end(config.m_SIDevice), std::begin(Pads));
   std::copy(std::begin(config.m_EXIDevice), std::end(config.m_EXIDevice), std::begin(m_EXIDevice));
 
-  bSetEmulationSpeed = false;
   bSetVolume = false;
   bSetWiimoteSource.fill(false);
   bSetPads.fill(false);
@@ -125,14 +113,11 @@ void ConfigCache::RestoreConfig(SConfig* config)
   valid = false;
 
   config->bCPUThread = bCPUThread;
-  config->bSyncGPUOnSkipIdleHack = bSyncGPUOnSkipIdleHack;
-  config->bDisableICache = bDisableICache;
   config->bMMU = bMMU;
   config->bSyncGPU = bSyncGPU;
   config->iSyncGpuMaxDistance = iSyncGpuMaxDistance;
   config->iSyncGpuMinDistance = iSyncGpuMinDistance;
   config->fSyncGpuOverclock = fSyncGpuOverclock;
-  config->bFastDiscSpeed = bFastDiscSpeed;
 
   // Only change these back if they were actually set by game ini, since they can be changed while a
   // game is running.
@@ -151,38 +136,15 @@ void ConfigCache::RestoreConfig(SConfig* config)
       config->m_SIDevice[i] = Pads[i];
   }
 
-  if (bSetEmulationSpeed)
-    config->m_EmulationSpeed = m_EmulationSpeed;
-
   for (unsigned int i = 0; i < ExpansionInterface::MAX_EXI_CHANNELS; ++i)
   {
     if (bSetEXIDevice[i])
       config->m_EXIDevice[i] = m_EXIDevice[i];
   }
-
-  config->m_strGPUDeterminismMode = m_strGPUDeterminismMode;
 }
 
 static ConfigCache config_cache;
 
-void SetEmulationSpeedReset(bool value)
-{
-  config_cache.bSetEmulationSpeed = value;
-}
-
-static GPUDeterminismMode ParseGPUDeterminismMode(const std::string& mode)
-{
-  if (mode == "auto")
-    return GPUDeterminismMode::Auto;
-  if (mode == "none")
-    return GPUDeterminismMode::Disabled;
-  if (mode == "fake-completion")
-    return GPUDeterminismMode::FakeCompletion;
-
-  NOTICE_LOG_FMT(BOOT, "Unknown GPU determinism mode {}", mode);
-  return GPUDeterminismMode::Auto;
-}
-
 // Boot the ISO or file
 bool BootCore(std::unique_ptr<BootParameters> boot, const WindowSystemInfo& wsi)
 {
@@ -206,17 +168,8 @@ bool BootCore(std::unique_ptr<BootParameters> boot, const WindowSystemInfo& wsi)
     IniFile::Section* controls_section = game_ini.GetOrCreateSection("Controls");
 
     core_section->Get("CPUThread", &StartUp.bCPUThread, StartUp.bCPUThread);
-    core_section->Get("SyncOnSkipIdle", &StartUp.bSyncGPUOnSkipIdleHack,
-                      StartUp.bSyncGPUOnSkipIdleHack);
-    core_section->Get("DisableICache", &StartUp.bDisableICache, StartUp.bDisableICache);
     core_section->Get("MMU", &StartUp.bMMU, StartUp.bMMU);
     core_section->Get("SyncGPU", &StartUp.bSyncGPU, StartUp.bSyncGPU);
-    core_section->Get("FastDiscSpeed", &StartUp.bFastDiscSpeed, StartUp.bFastDiscSpeed);
-    if (core_section->Get("EmulationSpeed", &StartUp.m_EmulationSpeed, StartUp.m_EmulationSpeed))
-      config_cache.bSetEmulationSpeed = true;
-
-    core_section->Get("GPUDeterminismMode", &StartUp.m_strGPUDeterminismMode,
-                      StartUp.m_strGPUDeterminismMode);
 
     for (unsigned int i = 0; i < SerialInterface::MAX_SI_CHANNELS; ++i)
     {
@@ -256,14 +209,11 @@ bool BootCore(std::unique_ptr<BootParameters> boot, const WindowSystemInfo& wsi)
     }
   }
 
-  StartUp.m_GPUDeterminismMode = ParseGPUDeterminismMode(StartUp.m_strGPUDeterminismMode);
-
   // Movie settings
   if (Movie::IsPlayingInput() && Movie::IsConfigSaved())
   {
     // TODO: remove this once ConfigManager starts using OnionConfig.
     StartUp.bCPUThread = Config::Get(Config::MAIN_CPU_THREAD);
-    StartUp.bFastDiscSpeed = Config::Get(Config::MAIN_FAST_DISC_SPEED);
     StartUp.bSyncGPU = Config::Get(Config::MAIN_SYNC_GPU);
     for (int i = 0; i < 2; ++i)
     {
@@ -293,17 +243,11 @@ bool BootCore(std::unique_ptr<BootParameters> boot, const WindowSystemInfo& wsi)
     config_cache.bSetEXIDevice[0] = true;
     config_cache.bSetEXIDevice[1] = true;
     config_cache.bSetEXIDevice[2] = true;
-    StartUp.bDisableICache = netplay_settings.m_DisableICache;
-    StartUp.bSyncGPUOnSkipIdleHack = netplay_settings.m_SyncOnSkipIdle;
     StartUp.bSyncGPU = netplay_settings.m_SyncGPU;
     StartUp.iSyncGpuMaxDistance = netplay_settings.m_SyncGpuMaxDistance;
     StartUp.iSyncGpuMinDistance = netplay_settings.m_SyncGpuMinDistance;
     StartUp.fSyncGpuOverclock = netplay_settings.m_SyncGpuOverclock;
-    StartUp.bFastDiscSpeed = netplay_settings.m_FastDiscSpeed;
     StartUp.bMMU = netplay_settings.m_MMU;
-    StartUp.bFastmem = netplay_settings.m_Fastmem;
-    if (netplay_settings.m_HostInputAuthority && !netplay_settings.m_IsHosting)
-      config_cache.bSetEmulationSpeed = true;
   }
   else
   {
@@ -355,7 +299,7 @@ bool BootCore(std::unique_ptr<BootParameters> boot, const WindowSystemInfo& wsi)
 
   // Disable loading time emulation for Riivolution-patched games until we have proper emulation.
   if (!boot->riivolution_patches.empty())
-    StartUp.bFastDiscSpeed = true;
+    Config::SetCurrent(Config::MAIN_FAST_DISC_SPEED, true);
 
   Core::UpdateWantDeterminism(/*initial*/ true);
 

Source/Core/Core/BootManager.h

@@ -11,7 +11,6 @@ struct WindowSystemInfo;
 namespace BootManager
 {
 bool BootCore(std::unique_ptr<BootParameters> parameters, const WindowSystemInfo& wsi);
-void SetEmulationSpeedReset(bool value);
 
 // Synchronise Dolphin's configuration with the SYSCONF (which may have changed during emulation),
 // and restore settings that were overriden by per-game INIs or for some other reason.

Source/Core/Core/Config/MainSettings.cpp

@@ -10,6 +10,7 @@
 #include "AudioCommon/AudioCommon.h"
 #include "Common/CommonPaths.h"
 #include "Common/Config/Config.h"
+#include "Common/Logging/Log.h"
 #include "Common/MathUtil.h"
 #include "Common/StringUtil.h"
 #include "Common/Version.h"
@@ -96,6 +97,8 @@ const Info<bool> MAIN_WII_KEYBOARD{{System::Main, "Core", "WiiKeyboard"}, false}
 const Info<bool> MAIN_WIIMOTE_CONTINUOUS_SCANNING{
     {System::Main, "Core", "WiimoteContinuousScanning"}, false};
 const Info<bool> MAIN_WIIMOTE_ENABLE_SPEAKER{{System::Main, "Core", "WiimoteEnableSpeaker"}, false};
+const Info<bool> MAIN_CONNECT_WIIMOTES_FOR_CONTROLLER_INTERFACE{
+    {System::Main, "Core", "WiimoteControllerInterface"}, false};
 const Info<bool> MAIN_MMU{{System::Main, "Core", "MMU"}, false};
 const Info<int> MAIN_BB_DUMP_PORT{{System::Main, "Core", "BBDumpPort"}, -1};
 const Info<bool> MAIN_SYNC_GPU{{System::Main, "Core", "SyncGPU"}, false};
@@ -118,8 +121,24 @@ const Info<u32> MAIN_MEM1_SIZE{{System::Main, "Core", "MEM1Size"}, Memory::MEM1_
 const Info<u32> MAIN_MEM2_SIZE{{System::Main, "Core", "MEM2Size"}, Memory::MEM2_SIZE_RETAIL};
 const Info<std::string> MAIN_GFX_BACKEND{{System::Main, "Core", "GFXBackend"},
                                          VideoBackendBase::GetDefaultBackendName()};
+
 const Info<std::string> MAIN_GPU_DETERMINISM_MODE{{System::Main, "Core", "GPUDeterminismMode"},
                                                   "auto"};
+
+GPUDeterminismMode GetGPUDeterminismMode()
+{
+  auto mode = Config::Get(Config::MAIN_GPU_DETERMINISM_MODE);
+  if (mode == "auto")
+    return GPUDeterminismMode::Auto;
+  if (mode == "none")
+    return GPUDeterminismMode::Disabled;
+  if (mode == "fake-completion")
+    return GPUDeterminismMode::FakeCompletion;
+
+  NOTICE_LOG_FMT(CORE, "Unknown GPU determinism mode {}", mode);
+  return GPUDeterminismMode::Auto;
+}
+
 const Info<std::string> MAIN_PERF_MAP_DIR{{System::Main, "Core", "PerfMapDir"}, ""};
 const Info<bool> MAIN_CUSTOM_RTC_ENABLE{{System::Main, "Core", "EnableCustomRTC"}, false};
 // Default to seconds between 1.1.1970 and 1.1.2000

Source/Core/Core/Config/MainSettings.h

@@ -72,6 +72,7 @@ extern const Info<bool> MAIN_WII_SD_CARD;
 extern const Info<bool> MAIN_WII_KEYBOARD;
 extern const Info<bool> MAIN_WIIMOTE_CONTINUOUS_SCANNING;
 extern const Info<bool> MAIN_WIIMOTE_ENABLE_SPEAKER;
+extern const Info<bool> MAIN_CONNECT_WIIMOTES_FOR_CONTROLLER_INTERFACE;
 extern const Info<bool> MAIN_MMU;
 extern const Info<int> MAIN_BB_DUMP_PORT;
 extern const Info<bool> MAIN_SYNC_GPU;
@@ -93,7 +94,18 @@ extern const Info<u32> MAIN_MEM1_SIZE;
 extern const Info<u32> MAIN_MEM2_SIZE;
 // Should really be part of System::GFX, but again, we're stuck with past mistakes.
 extern const Info<std::string> MAIN_GFX_BACKEND;
+
+enum class GPUDeterminismMode
+{
+  Auto,
+  Disabled,
+  // This is currently the only mode.  There will probably be at least
+  // one more at some point.
+  FakeCompletion,
+};
 extern const Info<std::string> MAIN_GPU_DETERMINISM_MODE;
+GPUDeterminismMode GetGPUDeterminismMode();
+
 extern const Info<std::string> MAIN_PERF_MAP_DIR;
 extern const Info<bool> MAIN_CUSTOM_RTC_ENABLE;
 extern const Info<u32> MAIN_CUSTOM_RTC_VALUE;

Source/Core/Core/ConfigLoaders/IsSettingSaveable.cpp

@@ -97,6 +97,19 @@ bool IsSettingSaveable(const Config::Location& config_location)
       &Config::GetInfoForSimulateKonga(1).GetLocation(),
       &Config::GetInfoForSimulateKonga(2).GetLocation(),
       &Config::GetInfoForSimulateKonga(3).GetLocation(),
+      &Config::MAIN_EMULATION_SPEED.GetLocation(),
+      &Config::MAIN_PERF_MAP_DIR.GetLocation(),
+      &Config::MAIN_GPU_DETERMINISM_MODE.GetLocation(),
+      &Config::MAIN_DISABLE_ICACHE.GetLocation(),
+      &Config::MAIN_FAST_DISC_SPEED.GetLocation(),
+      &Config::MAIN_SYNC_ON_SKIP_IDLE.GetLocation(),
+      &Config::MAIN_FASTMEM.GetLocation(),
+      &Config::MAIN_TIMING_VARIANCE.GetLocation(),
+      &Config::MAIN_WII_SD_CARD.GetLocation(),
+      &Config::MAIN_WII_KEYBOARD.GetLocation(),
+      &Config::MAIN_WIIMOTE_CONTINUOUS_SCANNING.GetLocation(),
+      &Config::MAIN_WIIMOTE_ENABLE_SPEAKER.GetLocation(),
+      &Config::MAIN_CONNECT_WIIMOTES_FOR_CONTROLLER_INTERFACE.GetLocation(),
 
       // UI.General