BootManager.cpp

// Copyright 2011 Dolphin Emulator Project
// Licensed under GPLv2+
// Refer to the license.txt file included.

// File description
// -------------
// Purpose of this file: Collect boot settings for Core::Init()

// Call sequence: This file has one of the first function called when a game is booted,
// the boot sequence in the code is:

// DolphinWX:    FrameTools.cpp         StartGame
// Core          BootManager.cpp        BootCore
//               Core.cpp               Init                     Thread creation
//                                      EmuThread                Calls CBoot::BootUp
//               Boot.cpp               CBoot::BootUp()
//                                      CBoot::EmulatedBS2_Wii() / GC() or Load_BS2()

// Includes
// ----------------
#include <algorithm>
#include <array>
#include <string>
#include <vector>

#include "Common/CommonTypes.h"
#include "Common/FileUtil.h"
#include "Common/IniFile.h"
#include "Common/SysConf.h"
#include "Core/BootManager.h"
#include "Core/ConfigManager.h"
#include "Core/Core.h"
#include "Core/HW/EXI.h"
#include "Core/HW/SI.h"
#include "Core/HW/Sram.h"
#include "Core/HW/WiimoteReal/WiimoteReal.h"
#include "Core/Host.h"
#include "Core/IPC_HLE/WII_IPC_HLE_Device_usb_bt_base.h"
#include "Core/Movie.h"
#include "Core/NetPlayProto.h"
#include "VideoCommon/VideoBackendBase.h"

namespace BootManager
{
// TODO this is an ugly hack which allows us to restore values trampled by per-game settings
// Apply fire liberally
struct ConfigCache
{
public:
  // fill the cache with values from the configuration
  void SaveConfig(const SConfig& config);
  // restore values to the configuration from the cache
  void RestoreConfig(SConfig* config);

  // These store if the relevant setting should be reset back later (true) or if it should be left
  // alone on restore (false)
  bool bSetEmulationSpeed;
  bool bSetVolume;
  bool bSetFrameSkip;
  std::array<bool, MAX_BBMOTES> bSetWiimoteSource;
  std::array<bool, MAX_SI_CHANNELS> bSetPads;
  std::array<bool, MAX_EXI_CHANNELS> bSetEXIDevice;

private:
  bool valid;
  bool bCPUThread;
  bool bEnableCheats;
  bool bSkipIdle;
  bool bSyncGPUOnSkipIdleHack;
  bool bFPRF;
  bool bAccurateNaNs;
  bool bMMU;
  bool bDCBZOFF;
  bool m_EnableJIT;
  bool bSyncGPU;
  bool bFastDiscSpeed;
  bool bDSPHLE;
  bool bHLE_BS2;
  bool bProgressive;
  bool bPAL60;
  int iSelectedLanguage;
  int iCPUCore;
  int Volume;
  unsigned int frameSkip;
  float m_EmulationSpeed;
  std::string strBackend;
  std::string sBackend;
  std::string m_strGPUDeterminismMode;
  std::array<int, MAX_BBMOTES> iWiimoteSource;
  std::array<SIDevices, MAX_SI_CHANNELS> Pads;
  std::array<TEXIDevices, MAX_EXI_CHANNELS> m_EXIDevice;
};

void ConfigCache::SaveConfig(const SConfig& config)
{
  valid = true;

  bCPUThread = config.bCPUThread;
  bEnableCheats = config.bEnableCheats;
  bSkipIdle = config.bSkipIdle;
  bSyncGPUOnSkipIdleHack = config.bSyncGPUOnSkipIdleHack;
  bFPRF = config.bFPRF;
  bAccurateNaNs = config.bAccurateNaNs;
  bMMU = config.bMMU;
  bDCBZOFF = config.bDCBZOFF;
  m_EnableJIT = config.m_DSPEnableJIT;
  bSyncGPU = config.bSyncGPU;
  bFastDiscSpeed = config.bFastDiscSpeed;
  bDSPHLE = config.bDSPHLE;
  bHLE_BS2 = config.bHLE_BS2;
  bProgressive = config.bProgressive;
  bPAL60 = config.bPAL60;
  iSelectedLanguage = config.SelectedLanguage;
  iCPUCore = config.iCPUCore;
  Volume = config.m_Volume;
  m_EmulationSpeed = config.m_EmulationSpeed;
  frameSkip = config.m_FrameSkip;
  strBackend = config.m_strVideoBackend;
  sBackend = config.sBackend;
  m_strGPUDeterminismMode = config.m_strGPUDeterminismMode;

  std::copy(std::begin(g_wiimote_sources), std::end(g_wiimote_sources), std::begin(iWiimoteSource));
  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;
  bSetFrameSkip = false;
  bSetWiimoteSource.fill(false);
  bSetPads.fill(false);
  bSetEXIDevice.fill(false);
}

void ConfigCache::RestoreConfig(SConfig* config)
{
  if (!valid)
    return;

  valid = false;

  config->bCPUThread = bCPUThread;
  config->bEnableCheats = bEnableCheats;
  config->bSkipIdle = bSkipIdle;
  config->bSyncGPUOnSkipIdleHack = bSyncGPUOnSkipIdleHack;
  config->bFPRF = bFPRF;
  config->bAccurateNaNs = bAccurateNaNs;
  config->bMMU = bMMU;
  config->bDCBZOFF = bDCBZOFF;
  config->m_DSPEnableJIT = m_EnableJIT;
  config->bSyncGPU = bSyncGPU;
  config->bFastDiscSpeed = bFastDiscSpeed;
  config->bDSPHLE = bDSPHLE;
  config->bHLE_BS2 = bHLE_BS2;
  config->bProgressive = bProgressive;
  config->bPAL60 = bPAL60;
  config->SelectedLanguage = iSelectedLanguage;
  config->iCPUCore = iCPUCore;

  config->m_SYSCONF->SetData("IPL.PGS", bProgressive);
  config->m_SYSCONF->SetData("IPL.E60", bPAL60);

  // Only change these back if they were actually set by game ini, since they can be changed while a
  // game is running.
  if (bSetVolume)
    config->m_Volume = Volume;

  if (config->bWii)
  {
    for (unsigned int i = 0; i < MAX_BBMOTES; ++i)
    {
      if (bSetWiimoteSource[i])
      {
        g_wiimote_sources[i] = iWiimoteSource[i];
        WiimoteReal::ChangeWiimoteSource(i, iWiimoteSource[i]);
      }
    }
  }

  for (unsigned int i = 0; i < MAX_SI_CHANNELS; ++i)
  {
    if (bSetPads[i])
      config->m_SIDevice[i] = Pads[i];
  }

  if (bSetEmulationSpeed)
    config->m_EmulationSpeed = m_EmulationSpeed;

  if (bSetFrameSkip)
  {
    config->m_FrameSkip = frameSkip;
    Movie::SetFrameSkipping(frameSkip);
  }

  for (unsigned int i = 0; i < MAX_EXI_CHANNELS; ++i)
  {
    if (bSetEXIDevice[i])
      config->m_EXIDevice[i] = m_EXIDevice[i];
  }

  config->m_strVideoBackend = strBackend;
  config->sBackend = sBackend;
  config->m_strGPUDeterminismMode = m_strGPUDeterminismMode;
  VideoBackendBase::ActivateBackend(config->m_strVideoBackend);
}

static ConfigCache config_cache;

static GPUDeterminismMode ParseGPUDeterminismMode(const std::string& mode)
{
  if (mode == "auto")
    return GPU_DETERMINISM_AUTO;
  if (mode == "none")
    return GPU_DETERMINISM_NONE;
  if (mode == "fake-completion")
    return GPU_DETERMINISM_FAKE_COMPLETION;

  NOTICE_LOG(BOOT, "Unknown GPU determinism mode %s", mode.c_str());
  return GPU_DETERMINISM_AUTO;
}

// Boot the ISO or file
bool BootCore(const std::string& _rFilename)
{
  SConfig& StartUp = SConfig::GetInstance();

  // Use custom settings for debugging mode
  Host_SetStartupDebuggingParameters();

  StartUp.m_BootType = SConfig::BOOT_ISO;
  StartUp.m_strFilename = _rFilename;
  SConfig::GetInstance().m_LastFilename = _rFilename;
  SConfig::GetInstance().SaveSettings();
  StartUp.bRunCompareClient = false;
  StartUp.bRunCompareServer = false;

  config_cache.SaveConfig(StartUp);

  // If for example the ISO file is bad we return here
  if (!StartUp.AutoSetup(SConfig::BOOT_DEFAULT))
    return false;

  // Load game specific settings
  {
    IniFile game_ini = StartUp.LoadGameIni();

    // General settings
    IniFile::Section* core_section = game_ini.GetOrCreateSection("Core");
    IniFile::Section* dsp_section = game_ini.GetOrCreateSection("DSP");
    IniFile::Section* controls_section = game_ini.GetOrCreateSection("Controls");

    core_section->Get("CPUThread", &StartUp.bCPUThread, StartUp.bCPUThread);
    core_section->Get("EnableCheats", &StartUp.bEnableCheats, StartUp.bEnableCheats);
    core_section->Get("SkipIdle", &StartUp.bSkipIdle, StartUp.bSkipIdle);
    core_section->Get("SyncOnSkipIdle", &StartUp.bSyncGPUOnSkipIdleHack,
                      StartUp.bSyncGPUOnSkipIdleHack);
    core_section->Get("FPRF", &StartUp.bFPRF, StartUp.bFPRF);
    core_section->Get("AccurateNaNs", &StartUp.bAccurateNaNs, StartUp.bAccurateNaNs);
    core_section->Get("MMU", &StartUp.bMMU, StartUp.bMMU);
    core_section->Get("DCBZ", &StartUp.bDCBZOFF, StartUp.bDCBZOFF);
    core_section->Get("SyncGPU", &StartUp.bSyncGPU, StartUp.bSyncGPU);
    core_section->Get("FastDiscSpeed", &StartUp.bFastDiscSpeed, StartUp.bFastDiscSpeed);
    core_section->Get("DSPHLE", &StartUp.bDSPHLE, StartUp.bDSPHLE);
    core_section->Get("GFXBackend", &StartUp.m_strVideoBackend, StartUp.m_strVideoBackend);
    core_section->Get("CPUCore", &StartUp.iCPUCore, StartUp.iCPUCore);
    core_section->Get("HLE_BS2", &StartUp.bHLE_BS2, StartUp.bHLE_BS2);
    core_section->Get("ProgressiveScan", &StartUp.bProgressive, StartUp.bProgressive);
    core_section->Get("PAL60", &StartUp.bPAL60, StartUp.bPAL60);
    if (core_section->Get("EmulationSpeed", &SConfig::GetInstance().m_EmulationSpeed,
                          SConfig::GetInstance().m_EmulationSpeed))
      config_cache.bSetEmulationSpeed = true;
    if (core_section->Get("FrameSkip", &SConfig::GetInstance().m_FrameSkip))
    {
      config_cache.bSetFrameSkip = true;
      Movie::SetFrameSkipping(SConfig::GetInstance().m_FrameSkip);
    }

    if (dsp_section->Get("Volume", &SConfig::GetInstance().m_Volume,
                         SConfig::GetInstance().m_Volume))
      config_cache.bSetVolume = true;
    dsp_section->Get("EnableJIT", &SConfig::GetInstance().m_DSPEnableJIT,
                     SConfig::GetInstance().m_DSPEnableJIT);
    dsp_section->Get("Backend", &SConfig::GetInstance().sBackend, SConfig::GetInstance().sBackend);
    VideoBackendBase::ActivateBackend(StartUp.m_strVideoBackend);
    core_section->Get("GPUDeterminismMode", &StartUp.m_strGPUDeterminismMode,
                      StartUp.m_strGPUDeterminismMode);

    for (unsigned int i = 0; i < MAX_SI_CHANNELS; ++i)
    {
      int source;
      controls_section->Get(StringFromFormat("PadType%u", i), &source, -1);
      if (source >= SIDEVICE_NONE && source < SIDEVICE_COUNT)
      {
        SConfig::GetInstance().m_SIDevice[i] = (SIDevices)source;
        config_cache.bSetPads[i] = true;
      }
    }

    // Wii settings
    if (StartUp.bWii)
    {
      // Flush possible changes to SYSCONF to file
      SConfig::GetInstance().m_SYSCONF->Save();

      int source;
      for (unsigned int i = 0; i < MAX_WIIMOTES; ++i)
      {
        controls_section->Get(StringFromFormat("WiimoteSource%u", i), &source, -1);
        if (source != -1 && g_wiimote_sources[i] != (unsigned)source &&
            source >= WIIMOTE_SRC_NONE && source <= WIIMOTE_SRC_HYBRID)
        {
          config_cache.bSetWiimoteSource[i] = true;
          g_wiimote_sources[i] = source;
          WiimoteReal::ChangeWiimoteSource(i, source);
        }
      }
      controls_section->Get("WiimoteSourceBB", &source, -1);
      if (source != -1 && g_wiimote_sources[WIIMOTE_BALANCE_BOARD] != (unsigned)source &&
          (source == WIIMOTE_SRC_NONE || source == WIIMOTE_SRC_REAL))
      {
        config_cache.bSetWiimoteSource[WIIMOTE_BALANCE_BOARD] = true;
        g_wiimote_sources[WIIMOTE_BALANCE_BOARD] = source;
        WiimoteReal::ChangeWiimoteSource(WIIMOTE_BALANCE_BOARD, source);
      }
    }
  }

  StartUp.m_GPUDeterminismMode = ParseGPUDeterminismMode(StartUp.m_strGPUDeterminismMode);

  // Movie settings
  if (Movie::IsPlayingInput() && Movie::IsConfigSaved())
  {
    StartUp.bCPUThread = Movie::IsDualCore();
    StartUp.bSkipIdle = Movie::IsSkipIdle();
    StartUp.bDSPHLE = Movie::IsDSPHLE();
    StartUp.bProgressive = Movie::IsProgressive();
    StartUp.bPAL60 = Movie::IsPAL60();
    StartUp.bFastDiscSpeed = Movie::IsFastDiscSpeed();
    StartUp.iCPUCore = Movie::GetCPUMode();
    StartUp.bSyncGPU = Movie::IsSyncGPU();
    if (!StartUp.bWii)
      StartUp.SelectedLanguage = Movie::GetLanguage();
    for (int i = 0; i < 2; ++i)
    {
      if (Movie::IsUsingMemcard(i) && Movie::IsStartingFromClearSave() && !StartUp.bWii)
      {
        if (File::Exists(File::GetUserPath(D_GCUSER_IDX) +
                         StringFromFormat("Movie%s.raw", (i == 0) ? "A" : "B")))
          File::Delete(File::GetUserPath(D_GCUSER_IDX) +
                       StringFromFormat("Movie%s.raw", (i == 0) ? "A" : "B"));
      }
    }
  }

  if (NetPlay::IsNetPlayRunning())
  {
    StartUp.bCPUThread = g_NetPlaySettings.m_CPUthread;
    StartUp.bEnableCheats = g_NetPlaySettings.m_EnableCheats;
    StartUp.bDSPHLE = g_NetPlaySettings.m_DSPHLE;
    StartUp.bEnableMemcardSdWriting = g_NetPlaySettings.m_WriteToMemcard;
    StartUp.iCPUCore = g_NetPlaySettings.m_CPUcore;
    StartUp.SelectedLanguage = g_NetPlaySettings.m_SelectedLanguage;
    StartUp.bOverrideGCLanguage = g_NetPlaySettings.m_OverrideGCLanguage;
    StartUp.bProgressive = g_NetPlaySettings.m_ProgressiveScan;
    StartUp.bPAL60 = g_NetPlaySettings.m_PAL60;
    SConfig::GetInstance().m_DSPEnableJIT = g_NetPlaySettings.m_DSPEnableJIT;
    SConfig::GetInstance().m_OCEnable = g_NetPlaySettings.m_OCEnable;
    SConfig::GetInstance().m_OCFactor = g_NetPlaySettings.m_OCFactor;
    SConfig::GetInstance().m_EXIDevice[0] = g_NetPlaySettings.m_EXIDevice[0];
    SConfig::GetInstance().m_EXIDevice[1] = g_NetPlaySettings.m_EXIDevice[1];
    config_cache.bSetEXIDevice[0] = true;
    config_cache.bSetEXIDevice[1] = true;
  }
  else
  {
    g_SRAM_netplay_initialized = false;
  }

  // Apply overrides
  // Some NTSC GameCube games such as Baten Kaitos react strangely to language settings that would
  // be invalid on an NTSC system
  if (!StartUp.bOverrideGCLanguage && StartUp.bNTSC)
  {
    StartUp.SelectedLanguage = 0;
  }

  // Some NTSC Wii games such as Doc Louis's Punch-Out!! and 1942 (Virtual Console) crash if the
  // PAL60 option is enabled
  if (StartUp.bWii && StartUp.bNTSC)
  {
    StartUp.bPAL60 = false;
  }

  SConfig::GetInstance().m_SYSCONF->SetData("IPL.PGS", StartUp.bProgressive);
  SConfig::GetInstance().m_SYSCONF->SetData("IPL.E60", StartUp.bPAL60);

  if (StartUp.bWii)
  {
    // Disable WiiConnect24's standby mode. If it is enabled, it prevents us from receiving
    // shutdown commands in the State Transition Manager (STM).
    // TODO: remove this if and once Dolphin supports WC24 standby mode.
    SConfig::GetInstance().m_SYSCONF->SetData<u8>("IPL.IDL", 0x00);
    NOTICE_LOG(BOOT, "Disabling WC24 'standby' (shutdown to idle) to avoid hanging on shutdown");

    RestoreBTInfoSection();
  }

  // Run the game
  // Init the core
  if (!Core::Init())
  {
    PanicAlertT("Couldn't init the core.\nCheck your configuration.");
    return false;
  }

  return true;
}

void Stop()
{
  Core::Stop();

  SConfig& StartUp = SConfig::GetInstance();
  StartUp.m_strUniqueID = "00000000";
  config_cache.RestoreConfig(&StartUp);
}

}  // namespace