winamp/Src/external_dependencies/openmpt-trunk/mptrack/TrackerSettings.cpp

/*
 * TrackerSettings.cpp
 * -------------------
 * Purpose: Code for managing, loading and saving all applcation settings.
 * Notes  : (currently none)
 * Authors: Olivier Lapicque
 *          OpenMPT Devs
 * The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
 */


#include "stdafx.h"
#include "Mptrack.h"
#include "Moddoc.h"
#include "Mainfrm.h"
#include "mpt/environment/environment.hpp"
#include "mpt/uuid/uuid.hpp"
#include "openmpt/sounddevice/SoundDevice.hpp"
#include "openmpt/sounddevice/SoundDeviceManager.hpp"
#include "../common/version.h"
#include "UpdateCheck.h"
#include "Mpdlgs.h"
#include "../common/mptStringBuffer.h"
#include "TrackerSettings.h"
#include "../common/misc_util.h"
#include "PatternClipboard.h"
#include "../common/ComponentManager.h"
#include "ExceptionHandler.h"
#include "../soundlib/mod_specifications.h"
#include "../soundlib/Tables.h"
#include "../common/mptFileIO.h"
#include "../soundlib/tuningcollection.h"
#include "TuningDialog.h"


#include <algorithm>


OPENMPT_NAMESPACE_BEGIN


#define OLD_SOUNDSETUP_REVERSESTEREO         0x20
#define OLD_SOUNDSETUP_SECONDARY             0x40
#define OLD_SOUNDSETUP_NOBOOSTTHREADPRIORITY 0x80

#ifndef NO_EQ

constexpr EQPreset FlatEQPreset = {"Flat", {16, 16, 16, 16, 16, 16}, {125, 300, 600, 1250, 4000, 8000}};

#endif // !NO_EQ


TrackerSettings &TrackerSettings::Instance()
{
	return theApp.GetTrackerSettings();
}


static Version GetPreviousSettingsVersion(const mpt::ustring &iniVersion)
{
	if(!iniVersion.empty())
	{
		return Version::Parse(iniVersion);
	} else
	{
		// No version stored.
		// This is the first run, thus set the previous version to our current
		// version which will avoid running all settings upgrade code.
		return Version::Current();
	}
}


mpt::ustring SettingsModTypeToString(MODTYPE modtype)
{
	return mpt::ToUnicode(mpt::Charset::UTF8, CSoundFile::GetModSpecifications(modtype).fileExtension);
}

MODTYPE SettingsStringToModType(const mpt::ustring &str)
{
	return CModSpecifications::ExtensionToType(mpt::ToCharset(mpt::Charset::UTF8, str));
}


static uint32 GetDefaultPatternSetup()
{
	return PATTERN_PLAYNEWNOTE | PATTERN_EFFECTHILIGHT
		| PATTERN_CENTERROW | PATTERN_DRAGNDROPEDIT
		| PATTERN_FLATBUTTONS | PATTERN_NOEXTRALOUD | PATTERN_2NDHIGHLIGHT
		| PATTERN_STDHIGHLIGHT | PATTERN_SHOWPREVIOUS | PATTERN_CONTSCROLL
		| PATTERN_SYNCMUTE | PATTERN_AUTODELAY | PATTERN_NOTEFADE
		| PATTERN_SHOWDEFAULTVOLUME | PATTERN_LIVEUPDATETREE | PATTERN_SYNCSAMPLEPOS;
}


void SampleUndoBufferSize::CalculateSize()
{
	if(sizePercent < 0)
		sizePercent = 0;
	MEMORYSTATUSEX memStatus;
	memStatus.dwLength = sizeof(MEMORYSTATUSEX);
	GlobalMemoryStatusEx(&memStatus);
	// The setting is a percentage of the memory that's actually *available* to OpenMPT, which is a max of 4GB in 32-bit mode.
	sizeByte = mpt::saturate_cast<size_t>(std::min(memStatus.ullTotalPhys, DWORDLONG(SIZE_T_MAX)) * sizePercent / 100);

	// Pretend there's at least one MiB of memory (haha)
	if(sizePercent != 0 && sizeByte < 1 * 1024 * 1024)
	{
		sizeByte = 1 * 1024 * 1024;
	}
}


DebugSettings::DebugSettings(SettingsContainer &conf)
	: conf(conf)
	// Debug
#if !defined(MPT_LOG_IS_DISABLED)
	, DebugLogLevel(conf, U_("Debug"), U_("LogLevel"), static_cast<int>(mpt::log::GlobalLogLevel))
	, DebugLogFacilitySolo(conf, U_("Debug"), U_("LogFacilitySolo"), std::string())
	, DebugLogFacilityBlocked(conf, U_("Debug"), U_("LogFacilityBlocked"), std::string())
	, DebugLogFileEnable(conf, U_("Debug"), U_("LogFileEnable"), mpt::log::FileEnabled)
	, DebugLogDebuggerEnable(conf, U_("Debug"), U_("LogDebuggerEnable"), mpt::log::DebuggerEnabled)
	, DebugLogConsoleEnable(conf, U_("Debug"), U_("LogConsoleEnable"), mpt::log::ConsoleEnabled)
#endif
	, DebugTraceEnable(conf, U_("Debug"), U_("TraceEnable"), false)
	, DebugTraceSize(conf, U_("Debug"), U_("TraceSize"), 1000000)
	, DebugTraceAlwaysDump(conf, U_("Debug"), U_("TraceAlwaysDump"), false)
	, DebugStopSoundDeviceOnCrash(conf, U_("Debug"), U_("StopSoundDeviceOnCrash"), true)
	, DebugStopSoundDeviceBeforeDump(conf, U_("Debug"), U_("StopSoundDeviceBeforeDump"), false)
	, DebugDelegateToWindowsHandler(conf, U_("Debug"), U_("DelegateToWindowsHandler"), false)
{

	// Duplicate state for debug stuff in order to avoid calling into settings framework from crash context.
	ExceptionHandler::stopSoundDeviceOnCrash = DebugStopSoundDeviceOnCrash;
	ExceptionHandler::stopSoundDeviceBeforeDump = DebugStopSoundDeviceBeforeDump;
	ExceptionHandler::delegateToWindowsHandler = DebugDelegateToWindowsHandler;

		// enable debug features (as early as possible after reading the settings)
	#if !defined(MPT_LOG_IS_DISABLED)
		#if !defined(MPT_LOG_GLOBAL_LEVEL_STATIC)
			mpt::log::GlobalLogLevel = DebugLogLevel;
		#endif
		mpt::log::SetFacilities(DebugLogFacilitySolo, DebugLogFacilityBlocked);
		mpt::log::FileEnabled = DebugLogFileEnable;
		mpt::log::DebuggerEnabled = DebugLogDebuggerEnable;
		mpt::log::ConsoleEnabled = DebugLogConsoleEnable;
	#endif
	if(DebugTraceEnable)
	{
		mpt::log::Trace::Enable(DebugTraceSize);
	}
}


DebugSettings::~DebugSettings()
{
	if(DebugTraceAlwaysDump)
	{
		DebugTraceDump();
	}
}


TrackerSettings::TrackerSettings(SettingsContainer &conf)
	: conf(conf)
	// Version
	, IniVersion(conf, U_("Version"), U_("Version"), mpt::ustring())
	, FirstRun(IniVersion.Get() == mpt::ustring())
	, PreviousSettingsVersion(GetPreviousSettingsVersion(IniVersion))
	, VersionInstallGUID(conf, U_("Version"), U_("InstallGUID"), mpt::UUID())
	// Display
	, m_ShowSplashScreen(conf, U_("Display"), U_("ShowSplashScreen"), true)
	, gbMdiMaximize(conf, U_("Display"), U_("MDIMaximize"), true)
	, highResUI(conf, U_("Display"), U_("HighResUI"), false)
	, glTreeSplitRatio(conf, U_("Display"), U_("MDITreeRatio"), 128)
	, glTreeWindowWidth(conf, U_("Display"), U_("MDITreeWidth"), 160)
	, glGeneralWindowHeight(conf, U_("Display"), U_("MDIGeneralHeight"), 222)
	, glPatternWindowHeight(conf, U_("Display"), U_("MDIPatternHeight"), 152)
	, glSampleWindowHeight(conf, U_("Display"), U_("MDISampleHeight"), 190)
	, glInstrumentWindowHeight(conf, U_("Display"), U_("MDIInstrumentHeight"), 300)
	, glCommentsWindowHeight(conf, U_("Display"), U_("MDICommentsHeight"), 288)
	, glGraphWindowHeight(conf, U_("Display"), U_("MDIGraphHeight"), 288)
	, gnPlugWindowX(conf, U_("Display"), U_("PlugSelectWindowX"), 243)
	, gnPlugWindowY(conf, U_("Display"), U_("PlugSelectWindowY"), 273)
	, gnPlugWindowWidth(conf, U_("Display"), U_("PlugSelectWindowWidth"), 450)
	, gnPlugWindowHeight(conf, U_("Display"), U_("PlugSelectWindowHeight"), 540)
	, gnPlugWindowLast(conf, U_("Display"), U_("PlugSelectWindowLast"), 0)
	, gnMsgBoxVisiblityFlags(conf, U_("Display"), U_("MsgBoxVisibilityFlags"), uint32_max)
	, GUIUpdateInterval(conf, U_("Display"), U_("GUIUpdateInterval"), 0)
	, FSUpdateInterval(conf, U_("Display"), U_("FSUpdateInterval"), 500)
	, VuMeterUpdateInterval(conf, U_("Display"), U_("VuMeterUpdateInterval"), 15)
	, VuMeterDecaySpeedDecibelPerSecond(conf, U_("Display"), U_("VuMeterDecaySpeedDecibelPerSecond"), 88.0f)
	, accidentalFlats(conf, U_("Display"), U_("AccidentalFlats"), false)
	, rememberSongWindows(conf, U_("Display"), U_("RememberSongWindows"), true)
	, showDirsInSampleBrowser(conf, U_("Display"), U_("ShowDirsInSampleBrowser"), false)
	, commentsFont(conf, U_("Display"), U_("Comments Font"), FontSetting(U_("Courier New"), 120))
	, defaultRainbowChannelColors(conf, U_("Display"), U_("DefaultChannelColors"), DefaultChannelColors::Random)
	// Misc
	, defaultModType(conf, U_("Misc"), U_("DefaultModType"), MOD_TYPE_IT)
	, defaultNewFileAction(conf, U_("Misc"), U_("DefaultNewFileAction"), nfDefaultFormat)
	, DefaultPlugVolumeHandling(conf, U_("Misc"), U_("DefaultPlugVolumeHandling"), PLUGIN_VOLUMEHANDLING_IGNORE)
	, autoApplySmoothFT2Ramping(conf, U_("Misc"), U_("SmoothFT2Ramping"), false)
	, MiscITCompressionStereo(conf, U_("Misc"), U_("ITCompressionStereo"), 4)
	, MiscITCompressionMono(conf, U_("Misc"), U_("ITCompressionMono"), 4)
	, MiscSaveChannelMuteStatus(conf, U_("Misc"), U_("SaveChannelMuteStatus"), true)
	, MiscAllowMultipleCommandsPerKey(conf, U_("Misc"), U_("AllowMultipleCommandsPerKey"), false)
	, MiscDistinguishModifiers(conf, U_("Misc"), U_("DistinguishModifiers"), false)
	, MiscProcessPriorityClass(conf, U_("Misc"), U_("ProcessPriorityClass"), ProcessPriorityClassNORMAL)
	, MiscFlushFileBuffersOnSave(conf, U_("Misc"), U_("FlushFileBuffersOnSave"), true)
	, MiscCacheCompleteFileBeforeLoading(conf, U_("Misc"), U_("CacheCompleteFileBeforeLoading"), false)
	, MiscUseSingleInstance(conf, U_("Misc"), U_("UseSingleInstance"), false)
	// Sound Settings
	, m_SoundShowRecordingSettings(false)
	, m_SoundShowDeprecatedDevices(conf, U_("Sound Settings"), U_("ShowDeprecatedDevices"), false)
	, m_SoundDeprecatedDeviceWarningShown(conf, U_("Sound Settings"), U_("DeprecatedDeviceWarningShown"), false)
	, m_SoundSampleRates(conf, U_("Sound Settings"), U_("SampleRates"), GetDefaultSampleRates())
	, m_SoundSettingsOpenDeviceAtStartup(conf, U_("Sound Settings"), U_("OpenDeviceAtStartup"), false)
	, m_SoundSettingsStopMode(conf, U_("Sound Settings"), U_("StopMode"), SoundDeviceStopModeClosed)
	, m_SoundDeviceSettingsUseOldDefaults(false)
	, m_SoundDeviceID_DEPRECATED(SoundDevice::Legacy::ID())
	, m_SoundDeviceIdentifier(conf, U_("Sound Settings"), U_("Device"), SoundDevice::Identifier())
	, MixerMaxChannels(conf, U_("Sound Settings"), U_("MixChannels"), MixerSettings().m_nMaxMixChannels)
	, MixerDSPMask(conf, U_("Sound Settings"), U_("Quality"), MixerSettings().DSPMask)
	, MixerFlags(conf, U_("Sound Settings"), U_("SoundSetup"), MixerSettings().MixerFlags)
	, MixerSamplerate(conf, U_("Sound Settings"), U_("Mixing_Rate"), MixerSettings().gdwMixingFreq)
	, MixerOutputChannels(conf, U_("Sound Settings"), U_("ChannelMode"), MixerSettings().gnChannels)
	, MixerPreAmp(conf, U_("Sound Settings"), U_("PreAmp"), MixerSettings().m_nPreAmp)
	, MixerStereoSeparation(conf, U_("Sound Settings"), U_("StereoSeparation"), MixerSettings().m_nStereoSeparation)
	, MixerVolumeRampUpMicroseconds(conf, U_("Sound Settings"), U_("VolumeRampUpMicroseconds"), MixerSettings().GetVolumeRampUpMicroseconds())
	, MixerVolumeRampDownMicroseconds(conf, U_("Sound Settings"), U_("VolumeRampDownMicroseconds"), MixerSettings().GetVolumeRampDownMicroseconds())
	, MixerNumInputChannels(conf, U_("Sound Settings"), U_("NumInputChannels"), static_cast<uint32>(MixerSettings().NumInputChannels))
	, ResamplerMode(conf, U_("Sound Settings"), U_("SrcMode"), CResamplerSettings().SrcMode)
	, ResamplerSubMode(conf, U_("Sound Settings"), U_("XMMSModplugResamplerWFIRType"), CResamplerSettings().gbWFIRType)
	, ResamplerCutoffPercent(conf, U_("Sound Settings"), U_("ResamplerWFIRCutoff"), mpt::saturate_round<int32>(CResamplerSettings().gdWFIRCutoff * 100.0))
	, ResamplerEmulateAmiga(conf, U_("Sound Settings"), U_("ResamplerEmulateAmiga"), Resampling::AmigaFilter::A1200)
	, SoundBoostedThreadPriority(conf, U_("Sound Settings"), U_("BoostedThreadPriority"), SoundDevice::AppInfo().BoostedThreadPriorityXP)
	, SoundBoostedThreadMMCSSClass(conf, U_("Sound Settings"), U_("BoostedThreadMMCSSClass"), SoundDevice::AppInfo().BoostedThreadMMCSSClassVista)
	, SoundBoostedThreadRealtimePosix(conf, U_("Sound Settings"), U_("BoostedThreadRealtimeLinux"), SoundDevice::AppInfo().BoostedThreadRealtimePosix)
	, SoundBoostedThreadNicenessPosix(conf, U_("Sound Settings"), U_("BoostedThreadNicenessPosix"), SoundDevice::AppInfo().BoostedThreadNicenessPosix)
	, SoundBoostedThreadRtprioPosix(conf, U_("Sound Settings"), U_("BoostedThreadRtprioLinux"), SoundDevice::AppInfo().BoostedThreadRtprioPosix)
	, SoundMaskDriverCrashes(conf, U_("Sound Settings"), U_("MaskDriverCrashes"), SoundDevice::AppInfo().MaskDriverCrashes)
	, SoundAllowDeferredProcessing(conf, U_("Sound Settings"), U_("AllowDeferredProcessing"), SoundDevice::AppInfo().AllowDeferredProcessing)
	// MIDI Settings
	, m_nMidiDevice(conf, U_("MIDI Settings"), U_("MidiDevice"), 0)
	, midiDeviceName(conf, U_("MIDI Settings"), U_("MidiDeviceName"), _T(""))
	, m_dwMidiSetup(conf, U_("MIDI Settings"), U_("MidiSetup"), MIDISETUP_RECORDVELOCITY | MIDISETUP_RECORDNOTEOFF | MIDISETUP_TRANSPOSEKEYBOARD | MIDISETUP_MIDITOPLUG)
	, aftertouchBehaviour(conf, U_("MIDI Settings"), U_("AftertouchBehaviour"), atDoNotRecord)
	, midiVelocityAmp(conf, U_("MIDI Settings"), U_("MidiVelocityAmp"), 100)
	, midiIgnoreCCs(conf, U_("MIDI Settings"), U_("IgnoredCCs"), std::bitset<128>())
	, midiImportPatternLen(conf, U_("MIDI Settings"), U_("MidiImportPatLen"), 128)
	, midiImportQuantize(conf, U_("MIDI Settings"), U_("MidiImportQuantize"), 32)
	, midiImportTicks(conf, U_("MIDI Settings"), U_("MidiImportTicks"), 6)
	// Pattern Editor
	, gbLoopSong(conf, U_("Pattern Editor"), U_("LoopSong"), true)
	, gnPatternSpacing(conf, U_("Pattern Editor"), U_("Spacing"), 0)
	, gbPatternVUMeters(conf, U_("Pattern Editor"), U_("VU-Meters"), true)
	, gbPatternPluginNames(conf, U_("Pattern Editor"), U_("Plugin-Names"), true)
	, gbPatternRecord(conf, U_("Pattern Editor"), U_("Record"), true)
	, patternNoEditPopup(conf, U_("Pattern Editor"), U_("NoEditPopup"), false)
	, patternStepCommands(conf, U_("Pattern Editor"), U_("EditStepAppliesToCommands"), false)
	, m_dwPatternSetup(conf, U_("Pattern Editor"), U_("PatternSetup"), GetDefaultPatternSetup())
	, m_nRowHighlightMeasures(conf, U_("Pattern Editor"), U_("RowSpacing"), 16)
	, m_nRowHighlightBeats(conf, U_("Pattern Editor"), U_("RowSpacing2"), 4)
	, recordQuantizeRows(conf, U_("Pattern Editor"), U_("RecordQuantize"), 0)
	, gnAutoChordWaitTime(conf, U_("Pattern Editor"), U_("AutoChordWaitTime"), 60)
	, orderlistMargins(conf, U_("Pattern Editor"), U_("DefaultSequenceMargins"), 0)
	, rowDisplayOffset(conf, U_("Pattern Editor"), U_("RowDisplayOffset"), 0)
	, patternFont(conf, U_("Pattern Editor"), U_("Font"), FontSetting(PATTERNFONT_SMALL, 0))
	, patternFontDot(conf, U_("Pattern Editor"), U_("FontDot"), U_("."))
	, effectVisWidth(conf, U_("Pattern Editor"), U_("EffectVisWidth"), -1)
	, effectVisHeight(conf, U_("Pattern Editor"), U_("EffectVisHeight"), -1)
	, effectVisX(conf, U_("Pattern Editor"), U_("EffectVisX"), int32_min)
	, effectVisY(conf, U_("Pattern Editor"), U_("EffectVisY"), int32_min)
	, patternAccessibilityFormat(conf, U_("Pattern Editor"), U_("AccessibilityFormat"), _T("Row %row%, Channel %channel%, %column_type%: %column_description%"))
	, patternAlwaysDrawWholePatternOnScrollSlow(conf, U_("Pattern Editor"), U_("AlwaysDrawWholePatternOnScrollSlow"), false)
	, orderListOldDropBehaviour(conf, U_("Pattern Editor"), U_("OrderListOldDropBehaviour"), false)
	// Sample Editor
	, m_SampleUndoBufferSize(conf, U_("Sample Editor"), U_("UndoBufferSize"), SampleUndoBufferSize())
	, sampleEditorKeyBehaviour(conf, U_("Sample Editor"), U_("KeyBehaviour"), seNoteOffOnNewKey)
	, m_defaultSampleFormat(conf, U_("Sample Editor"), U_("DefaultFormat"), dfFLAC)
	, sampleEditorTimelineFormat(conf, U_("Sample Editor"), U_("TimelineFormat"), TimelineFormat::Seconds)
	, sampleEditorDefaultResampler(conf, U_("Sample Editor"), U_("DefaultResampler"), SRCMODE_DEFAULT)
	, m_nFinetuneStep(conf, U_("Sample Editor"), U_("FinetuneStep"), 10)
	, m_FLACCompressionLevel(conf, U_("Sample Editor"), U_("FLACCompressionLevel"), 5)
	, compressITI(conf, U_("Sample Editor"), U_("CompressITI"), true)
	, m_MayNormalizeSamplesOnLoad(conf, U_("Sample Editor"), U_("MayNormalizeSamplesOnLoad"), true)
	, previewInFileDialogs(conf, U_("Sample Editor"), U_("PreviewInFileDialogs"), false)
	, cursorPositionInHex(conf, U_("Sample Editor"), U_("CursorPositionInHex"), false)
	// Export
	, ExportDefaultToSoundcardSamplerate(conf, U_("Export"), U_("DefaultToSoundcardSamplerate"), true)
	, ExportStreamEncoderSettings(conf, U_("Export"))
	// Components
	, ComponentsLoadOnStartup(conf, U_("Components"), U_("LoadOnStartup"), ComponentManagerSettingsDefault().LoadOnStartup())
	, ComponentsKeepLoaded(conf, U_("Components"), U_("KeepLoaded"), ComponentManagerSettingsDefault().KeepLoaded())
	// AutoSave
	, CreateBackupFiles(conf, U_("AutoSave"), U_("CreateBackupFiles"), true)
	, AutosaveEnabled(conf, U_("AutoSave"), U_("Enabled"), true)
	, AutosaveIntervalMinutes(conf, U_("AutoSave"), U_("IntervalMinutes"), 10)
	, AutosaveHistoryDepth(conf, U_("AutoSave"), U_("BackupHistory"), 3)
	, AutosaveUseOriginalPath(conf, U_("AutoSave"), U_("UseOriginalPath"), true)
	, AutosavePath(conf, U_("AutoSave"), U_("Path"), mpt::GetTempDirectory())
	// Paths
	, PathSongs(conf, U_("Paths"), U_("Songs_Directory"), mpt::PathString())
	, PathSamples(conf, U_("Paths"), U_("Samples_Directory"), mpt::PathString())
	, PathInstruments(conf, U_("Paths"), U_("Instruments_Directory"), mpt::PathString())
	, PathPlugins(conf, U_("Paths"), U_("Plugins_Directory"), mpt::PathString())
	, PathPluginPresets(conf, U_("Paths"), U_("Plugin_Presets_Directory"), mpt::PathString())
	, PathExport(conf, U_("Paths"), U_("Export_Directory"), mpt::PathString())
	, PathTunings(theApp.GetConfigPath() + P_("tunings\\"))
	, PathUserTemplates(theApp.GetConfigPath() + P_("TemplateModules\\"))
	// Default template
	, defaultTemplateFile(conf, U_("Paths"), U_("DefaultTemplate"), mpt::PathString())
	, defaultArtist(conf, U_("Misc"), U_("DefaultArtist"), mpt::getenv(U_("USERNAME")).value_or(U_("")))
	// MRU List
	, mruListLength(conf, U_("Misc"), U_("MRUListLength"), 10)
	// Plugins
	, bridgeAllPlugins(conf, U_("VST Plugins"), U_("BridgeAllPlugins"), false)
	, enableAutoSuspend(conf, U_("VST Plugins"), U_("EnableAutoSuspend"), false)
	, midiMappingInPluginEditor(conf, U_("VST Plugins"), U_("EnableMidiMappingInEditor"), true)
	, pluginProjectPath(conf, U_("VST Plugins"), U_("ProjectPath"), mpt::ustring())
	, vstHostProductString(conf, U_("VST Plugins"), U_("HostProductString"), "OpenMPT")
	, vstHostVendorString(conf, U_("VST Plugins"), U_("HostVendorString"), "OpenMPT project")
	, vstHostVendorVersion(conf, U_("VST Plugins"), U_("HostVendorVersion"), Version::Current().GetRawVersion())
	// Broken Plugins Workarounds
	, BrokenPluginsWorkaroundVSTMaskAllCrashes(conf, U_("Broken Plugins Workarounds"), U_("VSTMaskAllCrashes"), true)  // TODO: really should be false
	, BrokenPluginsWorkaroundVSTNeverUnloadAnyPlugin(conf, U_("Broken Plugins Workarounds"), U_("VSTNeverUnloadAnyPlugin"), false)
#if defined(MPT_ENABLE_UPDATE)
	// Update
	, UpdateEnabled(conf, U_("Update"), U_("Enabled"), true)
	, UpdateInstallAutomatically(conf, U_("Update"), U_("InstallAutomatically"), false)
	, UpdateLastUpdateCheck(conf, U_("Update"), U_("LastUpdateCheck"), mpt::Date::Unix(time_t()))
	, UpdateUpdateCheckPeriod_DEPRECATED(conf, U_("Update"), U_("UpdateCheckPeriod"), 7)
	, UpdateIntervalDays(conf, U_("Update"), U_("UpdateCheckIntervalDays"), 7)
	, UpdateChannel(conf, U_("Update"), U_("Channel"), UpdateChannelRelease)
	, UpdateUpdateURL_DEPRECATED(conf, U_("Update"), U_("UpdateURL"), U_("https://update.openmpt.org/check/$VERSION/$GUID"))
	, UpdateAPIURL(conf, U_("Update"), U_("APIURL"), CUpdateCheck::GetDefaultAPIURL())
	, UpdateStatisticsConsentAsked(conf, U_("Update"), U_("StatistisConsentAsked"), false)
	, UpdateStatistics(conf, U_("Update"), U_("Statistis"), false)
	, UpdateSendGUID_DEPRECATED(conf, U_("Update"), U_("SendGUID"), false)
	, UpdateShowUpdateHint(conf, U_("Update"), U_("ShowUpdateHint"), true)
	, UpdateIgnoreVersion(conf, U_("Update"), U_("IgnoreVersion"), _T(""))
	, UpdateSkipSignatureVerificationUNSECURE(conf, U_("Update"), U_("SkipSignatureVerification"), false)
	, UpdateSigningKeysRootAnchors(conf, U_("Update"), U_("SigningKeysRootAnchors"), CUpdateCheck::GetDefaultUpdateSigningKeysRootAnchors())
#endif // MPT_ENABLE_UPDATE
	// Wine suppport
	, WineSupportEnabled(conf, U_("WineSupport"), U_("Enabled"), false)
	, WineSupportAlwaysRecompile(conf, U_("WineSupport"), U_("AlwaysRecompile"), false)
	, WineSupportAskCompile(conf, U_("WineSupport"), U_("AskCompile"), false)
	, WineSupportCompileVerbosity(conf, U_("WineSupport"), U_("CompileVerbosity"), 2) // 0=silent 1=silentmake 2=progresswindow 3=standard 4=verbosemake 5=veryverbosemake 6=msgboxes
	, WineSupportForeignOpenMPT(conf, U_("WineSupport"), U_("ForeignOpenMPT"), false)
	, WineSupportAllowUnknownHost(conf, U_("WineSupport"), U_("AllowUnknownHost"), false)
	, WineSupportEnablePulseAudio(conf, U_("WineSupport"), U_("EnablePulseAudio"), 1)
	, WineSupportEnablePortAudio(conf, U_("WineSupport"), U_("EnablePortAudio"), 1)
	, WineSupportEnableRtAudio(conf, U_("WineSupport"), U_("EnableRtAudio"), 1)
{

	// Effects
#ifndef NO_DSP
	m_MegaBassSettings.m_nXBassDepth = conf.Read<int32>(U_("Effects"), U_("XBassDepth"), m_MegaBassSettings.m_nXBassDepth);
	m_MegaBassSettings.m_nXBassRange = conf.Read<int32>(U_("Effects"), U_("XBassRange"), m_MegaBassSettings.m_nXBassRange);
#endif
#ifndef NO_REVERB
	m_ReverbSettings.m_nReverbDepth = conf.Read<int32>(U_("Effects"), U_("ReverbDepth"), m_ReverbSettings.m_nReverbDepth);
	m_ReverbSettings.m_nReverbType = conf.Read<int32>(U_("Effects"), U_("ReverbType"), m_ReverbSettings.m_nReverbType);
#endif
#ifndef NO_DSP
	m_SurroundSettings.m_nProLogicDepth = conf.Read<int32>(U_("Effects"), U_("ProLogicDepth"), m_SurroundSettings.m_nProLogicDepth);
	m_SurroundSettings.m_nProLogicDelay = conf.Read<int32>(U_("Effects"), U_("ProLogicDelay"), m_SurroundSettings.m_nProLogicDelay);
#endif
#ifndef NO_EQ
	m_EqSettings = conf.Read<EQPreset>(U_("Effects"), U_("EQ_Settings"), FlatEQPreset);
	const EQPreset userPresets[] =
	{
		FlatEQPreset,
		{ "User 1", {16,16,16,16,16,16}, { 150, 350, 700, 1500, 4500, 8000 } },
		{ "User 2", {16,16,16,16,16,16}, { 200, 400, 800, 1750, 5000, 9000 } },
		{ "User 3", {16,16,16,16,16,16}, { 250, 450, 900, 2000, 5000, 10000 } }
	};

	m_EqUserPresets[0] = conf.Read<EQPreset>(U_("Effects"), U_("EQ_User1"), userPresets[0]);
	m_EqUserPresets[1] = conf.Read<EQPreset>(U_("Effects"), U_("EQ_User2"), userPresets[1]);
	m_EqUserPresets[2] = conf.Read<EQPreset>(U_("Effects"), U_("EQ_User3"), userPresets[2]);
	m_EqUserPresets[3] = conf.Read<EQPreset>(U_("Effects"), U_("EQ_User4"), userPresets[3]);
#endif
#ifndef NO_DSP
	m_BitCrushSettings.m_Bits = conf.Read<int32>(U_("Effects"), U_("BitCrushBits"), m_BitCrushSettings.m_Bits);
#endif
	// Display (Colors)
	GetDefaultColourScheme(rgbCustomColors);
	for(int ncol = 0; ncol < MAX_MODCOLORS; ncol++)
	{
		const mpt::ustring colorName = MPT_UFORMAT("Color{}")(mpt::ufmt::dec0<2>(ncol));
		rgbCustomColors[ncol] = conf.Read<uint32>(U_("Display"), colorName, rgbCustomColors[ncol]);
	}
	// Paths
	m_szKbdFile = conf.Read<mpt::PathString>(U_("Paths"), U_("Key_Config_File"), mpt::PathString());
	conf.Forget(U_("Paths"), U_("Key_Config_File"));

	// init old and messy stuff:

	// Default chords
	MemsetZero(Chords);
	for(UINT ichord = 0; ichord < 3 * 12; ichord++)
	{
		Chords[ichord].key = (uint8)ichord;
		Chords[ichord].notes[0] = MPTChord::noNote;
		Chords[ichord].notes[1] = MPTChord::noNote;
		Chords[ichord].notes[2] = MPTChord::noNote;

		if(ichord < 12)
		{
			// Major Chords
			Chords[ichord].notes[0] = (int8)(ichord + 4);
			Chords[ichord].notes[1] = (int8)(ichord + 7);
			Chords[ichord].notes[2] = (int8)(ichord + 10);
		} else if(ichord < 24)
		{
			// Minor Chords
			Chords[ichord].notes[0] = (int8)(ichord - 9);
			Chords[ichord].notes[1] = (int8)(ichord - 5);
			Chords[ichord].notes[2] = (int8)(ichord - 2);
		}
	}


	// load old and messy stuff:

	PatternClipboard::SetClipboardSize(conf.Read<int32>(U_("Pattern Editor"), U_("NumClipboards"), mpt::saturate_cast<int32>(PatternClipboard::GetClipboardSize())));

	// Chords
	LoadChords(Chords);

	// Zxx Macros
	MIDIMacroConfig macros;
	theApp.GetDefaultMidiMacro(macros);
	for(int i = 0; i < kSFxMacros; i++)
	{
		macros.SFx[i] = conf.Read<std::string>(U_("Zxx Macros"), MPT_UFORMAT("SF{}")(mpt::ufmt::HEX(i)), macros.SFx[i]);
	}
	for(int i = 0; i < kZxxMacros; i++)
	{
		macros.Zxx[i] = conf.Read<std::string>(U_("Zxx Macros"), MPT_UFORMAT("Z{}")(mpt::ufmt::HEX0<2>(i | 0x80)), macros.Zxx[i]);
	}


	// MRU list
	Limit(mruListLength, 0u, 32u);
	mruFiles.reserve(mruListLength);
	for(uint32 i = 0; i < mruListLength; i++)
	{
		mpt::ustring key = MPT_UFORMAT("File{}")(i);

		mpt::PathString path = theApp.PathInstallRelativeToAbsolute(conf.Read<mpt::PathString>(U_("Recent File List"), key, mpt::PathString()));
		if(!path.empty())
		{
			mruFiles.push_back(path);
		}
	}

	// Fixups:
	// -------

	const Version storedVersion = PreviousSettingsVersion;

	// Version
	if(!VersionInstallGUID.Get().IsValid())
	{
		// No UUID found - generate one.
		VersionInstallGUID = mpt::UUID::Generate(mpt::global_prng());
	}

	// Plugins
	if(storedVersion < MPT_V("1.19.03.01") && vstHostProductString.Get() == "OpenMPT")
	{
		vstHostVendorVersion = Version::Current().GetRawVersion();
	}
	if(storedVersion < MPT_V("1.30.00.24"))
	{
		BrokenPluginsWorkaroundVSTNeverUnloadAnyPlugin = !conf.Read<bool>(U_("VST Plugins"), U_("FullyUnloadPlugins"), true);
		conf.Remove(U_("VST Plugins"), U_("FullyUnloadPlugins"));
	}

	// Sound Settings
	if(storedVersion < MPT_V("1.22.07.30"))
	{
		if(conf.Read<bool>(U_("Sound Settings"), U_("KeepDeviceOpen"), false))
		{
			m_SoundSettingsStopMode = SoundDeviceStopModePlaying;
		} else
		{
			m_SoundSettingsStopMode = SoundDeviceStopModeStopped;
		}
	}
	if(storedVersion < MPT_V("1.22.07.04"))
	{
		std::vector<uint32> sampleRates = m_SoundSampleRates;
		if(std::count(sampleRates.begin(), sampleRates.end(), MixerSamplerate) == 0)
		{
			sampleRates.push_back(MixerSamplerate);
			std::sort(sampleRates.begin(), sampleRates.end());
			std::reverse(sampleRates.begin(), sampleRates.end());
			m_SoundSampleRates = sampleRates;
		}
	}
	if(storedVersion < MPT_V("1.22.07.04"))
	{
		m_SoundDeviceID_DEPRECATED = conf.Read<SoundDevice::Legacy::ID>(U_("Sound Settings"), U_("WaveDevice"), SoundDevice::Legacy::ID());
		Setting<uint32> m_BufferLength_DEPRECATED(conf, U_("Sound Settings"), U_("BufferLength"), 50);
		Setting<uint32> m_LatencyMS(conf, U_("Sound Settings"), U_("Latency"), mpt::saturate_round<int32>(SoundDevice::Settings().Latency * 1000.0));
		Setting<uint32> m_UpdateIntervalMS(conf, U_("Sound Settings"), U_("UpdateInterval"), mpt::saturate_round<int32>(SoundDevice::Settings().UpdateInterval * 1000.0));
		Setting<SampleFormat> m_SampleFormat(conf, U_("Sound Settings"), U_("BitsPerSample"), SoundDevice::Settings().sampleFormat);
		Setting<bool> m_SoundDeviceExclusiveMode(conf, U_("Sound Settings"), U_("ExclusiveMode"), SoundDevice::Settings().ExclusiveMode);
		Setting<bool> m_SoundDeviceBoostThreadPriority(conf, U_("Sound Settings"), U_("BoostThreadPriority"), SoundDevice::Settings().BoostThreadPriority);
		Setting<bool> m_SoundDeviceUseHardwareTiming(conf, U_("Sound Settings"), U_("UseHardwareTiming"), SoundDevice::Settings().UseHardwareTiming);
		Setting<SoundDevice::ChannelMapping> m_SoundDeviceChannelMapping(conf, U_("Sound Settings"), U_("ChannelMapping"), SoundDevice::Settings().Channels);
		if(storedVersion < MPT_V("1.21.01.26"))
		{
			if(m_BufferLength_DEPRECATED != 0)
			{
				if(m_BufferLength_DEPRECATED < 1) m_BufferLength_DEPRECATED = 1; // 1ms
				if(m_BufferLength_DEPRECATED > 1000) m_BufferLength_DEPRECATED = 1000; // 1sec
				if((m_SoundDeviceID_DEPRECATED & SoundDevice::Legacy::MaskType) == SoundDevice::Legacy::TypeASIO)
				{
					m_LatencyMS = m_BufferLength_DEPRECATED * 1;
					m_UpdateIntervalMS = m_BufferLength_DEPRECATED / 8;
				} else
				{
					m_LatencyMS = m_BufferLength_DEPRECATED * 3;
					m_UpdateIntervalMS = m_BufferLength_DEPRECATED / 8;
				}
				if(!m_UpdateIntervalMS) m_UpdateIntervalMS = static_cast<uint32>(SoundDevice::Settings().UpdateInterval * 1000.0);
			}
			conf.Remove(m_BufferLength_DEPRECATED.GetPath());
		}
		if(storedVersion < MPT_V("1.22.01.03"))
		{
			m_SoundDeviceExclusiveMode = ((MixerFlags & OLD_SOUNDSETUP_SECONDARY) == 0);
		}
		if(storedVersion < MPT_V("1.22.01.03"))
		{
			m_SoundDeviceBoostThreadPriority = ((MixerFlags & OLD_SOUNDSETUP_NOBOOSTTHREADPRIORITY) == 0);
		}
		if(storedVersion < MPT_V("1.22.07.03"))
		{
			m_SoundDeviceChannelMapping = SoundDevice::ChannelMapping::BaseChannel(MixerOutputChannels, conf.Read<int>(U_("Sound Settings"), U_("ASIOBaseChannel"), 0));
		}
		m_SoundDeviceSettingsDefaults.Latency = m_LatencyMS / 1000.0;
		m_SoundDeviceSettingsDefaults.UpdateInterval = m_UpdateIntervalMS / 1000.0;
		m_SoundDeviceSettingsDefaults.Samplerate = MixerSamplerate;
		if(m_SoundDeviceSettingsDefaults.Channels.GetNumHostChannels() != MixerOutputChannels)
		{
			// reset invalid channel mapping to default
			m_SoundDeviceSettingsDefaults.Channels = SoundDevice::ChannelMapping(MixerOutputChannels);
		}
		m_SoundDeviceSettingsDefaults.InputChannels = 0;
		m_SoundDeviceSettingsDefaults.sampleFormat = m_SampleFormat;
		m_SoundDeviceSettingsDefaults.ExclusiveMode = m_SoundDeviceExclusiveMode;
		m_SoundDeviceSettingsDefaults.BoostThreadPriority = m_SoundDeviceBoostThreadPriority;
		m_SoundDeviceSettingsDefaults.UseHardwareTiming = m_SoundDeviceUseHardwareTiming;
		m_SoundDeviceSettingsDefaults.InputSourceID = 0;
		m_SoundDeviceSettingsUseOldDefaults = true;
	}
	if(storedVersion < MPT_V("1.28.00.41"))
	{
		// reset this setting to the default when updating,
		// because we do not provide a GUI any more,
		// and in general, it should not get changed anyway
		ResamplerCutoffPercent = mpt::saturate_round<int32>(CResamplerSettings().gdWFIRCutoff * 100.0);
	}
	if(MixerSamplerate == 0)
	{
		MixerSamplerate = MixerSettings().gdwMixingFreq;
	}
	if(storedVersion < MPT_V("1.21.01.26"))
	{
		MixerFlags &= ~OLD_SOUNDSETUP_REVERSESTEREO;
	}
	if(storedVersion < MPT_V("1.22.01.03"))
	{
		MixerFlags &= ~OLD_SOUNDSETUP_SECONDARY;
	}
	if(storedVersion < MPT_V("1.22.01.03"))
	{
		MixerFlags &= ~OLD_SOUNDSETUP_NOBOOSTTHREADPRIORITY;
	}
	if(storedVersion < MPT_V("1.20.00.22"))
	{
		MixerSettings settings = GetMixerSettings();
		settings.SetVolumeRampUpSamples(conf.Read<int32>(U_("Sound Settings"), U_("VolumeRampSamples"), 42));
		settings.SetVolumeRampDownSamples(conf.Read<int32>(U_("Sound Settings"), U_("VolumeRampSamples"), 42));
		SetMixerSettings(settings);
		conf.Remove(U_("Sound Settings"), U_("VolumeRampSamples"));
	} else if(storedVersion < MPT_V("1.22.07.18"))
	{
		MixerSettings settings = GetMixerSettings();
		settings.SetVolumeRampUpSamples(conf.Read<int32>(U_("Sound Settings"), U_("VolumeRampUpSamples"), MixerSettings().GetVolumeRampUpSamples()));
		settings.SetVolumeRampDownSamples(conf.Read<int32>(U_("Sound Settings"), U_("VolumeRampDownSamples"), MixerSettings().GetVolumeRampDownSamples()));
		SetMixerSettings(settings);
	}
	Limit(ResamplerCutoffPercent, 0, 100);
	if(storedVersion < MPT_V("1.29.00.11"))
	{
		MixerMaxChannels = MixerSettings().m_nMaxMixChannels;  // reset to default on update because we removed the setting in the GUI
	}
	if(storedVersion < MPT_V("1.29.00.20"))
	{
		MixerDSPMask = MixerDSPMask & ~SNDDSP_BITCRUSH;
	}

	// Misc
	if(defaultModType == MOD_TYPE_NONE)
	{
		defaultModType = MOD_TYPE_IT;
	}

	// MIDI Settings
	if((m_dwMidiSetup & 0x40) != 0 && storedVersion < MPT_V("1.20.00.86"))
	{
		// This flag used to be "amplify MIDI Note Velocity" - with a fixed amplification factor of 2.
		midiVelocityAmp = 200;
		m_dwMidiSetup &= ~0x40;
	}

	// Pattern Editor
	if(storedVersion < MPT_V("1.17.02.50"))
	{
		m_dwPatternSetup |= PATTERN_NOTEFADE;
	}
	if(storedVersion < MPT_V("1.17.03.01"))
	{
		m_dwPatternSetup |= PATTERN_RESETCHANNELS;
	}
	if(storedVersion < MPT_V("1.19.00.07"))
	{
		m_dwPatternSetup &= ~0x800;					// this was previously deprecated and is now used for something else
	}
	if(storedVersion < MPT_V("1.20.00.04"))
	{
		m_dwPatternSetup &= ~0x200000;				// ditto
	}
	if(storedVersion < MPT_V("1.20.00.07"))
	{
		m_dwPatternSetup &= ~0x400000;				// ditto
	}
	if(storedVersion < MPT_V("1.20.00.39"))
	{
		m_dwPatternSetup &= ~0x10000000;			// ditto
	}
	if(storedVersion < MPT_V("1.24.01.04"))
	{
		commentsFont = FontSetting(U_("Courier New"), (m_dwPatternSetup & 0x02) ? 120 : 90);
		patternFont = FontSetting((m_dwPatternSetup & 0x08) ? PATTERNFONT_SMALL : PATTERNFONT_LARGE, 0);
		m_dwPatternSetup &= ~(0x08 | 0x02);
	}
	if(storedVersion < MPT_V("1.25.00.08") && glGeneralWindowHeight < 222)
	{
		glGeneralWindowHeight += 44;
	}
	if(storedVersion < MPT_V("1.25.00.16") && (m_dwPatternSetup & 0x100000))
	{
		// Move MIDI recording to MIDI setup
		m_dwPatternSetup &= ~0x100000;
		m_dwMidiSetup |= MIDISETUP_ENABLE_RECORD_DEFAULT;
	}
	if(storedVersion < MPT_V("1.27.00.51"))
	{
		// Moving option out of pattern config
		CreateBackupFiles = (m_dwPatternSetup & 0x200) != 0;
		m_dwPatternSetup &= ~0x200;
	}

	// Export
	if(storedVersion < MPT_V("1.30.00.38"))
	{
		{
			conf.Write<Encoder::Mode>(U_("Export"), U_("FLAC_Mode"), Encoder::ModeLossless);
			const int oldformat = conf.Read<int>(U_("Export"), U_("FLAC_Format"), 1);
			Encoder::Format newformat = { Encoder::Format::Encoding::Integer, 24, mpt::get_endian() };
			if (oldformat >= 0)
			{
				switch (oldformat % 3)
				{
				case 0:
					newformat = { Encoder::Format::Encoding::Integer, 24, mpt::get_endian() };
					break;
				case 1:
					newformat = { Encoder::Format::Encoding::Integer, 16, mpt::get_endian() };
					break;
				case 2:
					newformat = { Encoder::Format::Encoding::Integer, 8, mpt::get_endian() };
					break;
				}
			}
			conf.Write<Encoder::Format>(U_("Export"), U_("FLAC_Format2"), newformat);
			conf.Forget(U_("Export"), U_("FLAC_Format"));
		}
		{
			conf.Write<Encoder::Mode>(U_("Export"), U_("Wave_Mode"), Encoder::ModeLossless);
			const int oldformat = conf.Read<int>(U_("Export"), U_("Wave_Format"), 1);
			Encoder::Format newformat = { Encoder::Format::Encoding::Float, 32, mpt::endian::little };
			if (oldformat >= 0)
			{
				switch (oldformat % 6)
				{
				case 0:
					newformat = { Encoder::Format::Encoding::Float, 64, mpt::endian::little };
					break;
				case 1:
					newformat = { Encoder::Format::Encoding::Float, 32, mpt::endian::little };
					break;
				case 2:
					newformat = { Encoder::Format::Encoding::Integer, 32, mpt::endian::little };
					break;
				case 3:
					newformat = { Encoder::Format::Encoding::Integer, 24, mpt::endian::little };
					break;
				case 4:
					newformat = { Encoder::Format::Encoding::Integer, 16, mpt::endian::little };
					break;
				case 5:
					newformat = { Encoder::Format::Encoding::Unsigned, 8, mpt::endian::little };
					break;
				}
			}
			conf.Write<Encoder::Format>(U_("Export"), U_("Wave_Format2"), newformat);
			conf.Forget(U_("Export"), U_("Wave_Format"));
		}
		{
			conf.Write<Encoder::Mode>(U_("Export"), U_("AU_Mode"), Encoder::ModeLossless);
			const int oldformat = conf.Read<int>(U_("Export"), U_("AU_Format"), 1);
			Encoder::Format newformat = { Encoder::Format::Encoding::Float, 32, mpt::endian::big };
			if(oldformat >= 0)
			{
				switch(oldformat % 6)
				{
				case 0:
					newformat = { Encoder::Format::Encoding::Float, 64, mpt::endian::big };
					break;
				case 1:
					newformat = { Encoder::Format::Encoding::Float, 32, mpt::endian::big };
					break;
				case 2:
					newformat = { Encoder::Format::Encoding::Integer, 32, mpt::endian::big };
					break;
				case 3:
					newformat = { Encoder::Format::Encoding::Integer, 24, mpt::endian::big };
					break;
				case 4:
					newformat = { Encoder::Format::Encoding::Integer, 16, mpt::endian::big };
					break;
				case 5:
					newformat = { Encoder::Format::Encoding::Integer, 8, mpt::endian::big };
					break;
				}
			}
			conf.Write<Encoder::Format>(U_("Export"), U_("AU_Format2"), newformat);
			conf.Forget(U_("Export"), U_("AU_Format"));
		}
		{
			conf.Write<Encoder::Mode>(U_("Export"), U_("RAW_Mode"), Encoder::ModeLossless);
			const int oldformat = conf.Read<int>(U_("Export"), U_("RAW_Format"), 1);
			Encoder::Format newformat = { Encoder::Format::Encoding::Float, 32, mpt::get_endian() };
			if(oldformat >= 0)
			{
				switch(oldformat % 7)
				{
				case 0:
					newformat = { Encoder::Format::Encoding::Float, 64, mpt::get_endian() };
					break;
				case 1:
					newformat = { Encoder::Format::Encoding::Float, 32, mpt::get_endian() };
					break;
				case 2:
					newformat = { Encoder::Format::Encoding::Integer, 32, mpt::get_endian() };
					break;
				case 3:
					newformat = { Encoder::Format::Encoding::Integer, 24, mpt::get_endian() };
					break;
				case 4:
					newformat = { Encoder::Format::Encoding::Integer, 16, mpt::get_endian() };
					break;
				case 5:
					newformat = { Encoder::Format::Encoding::Integer, 8, mpt::get_endian() };
					break;
				case 6:
					newformat = { Encoder::Format::Encoding::Unsigned, 8, mpt::get_endian() };
					break;
				}
			}
			conf.Write<Encoder::Format>(U_("Export"), U_("RAW_Format2"), newformat);
			conf.Forget(U_("Export"), U_("RAW_Format"));
		}
	}

#if defined(MPT_ENABLE_UPDATE)
	// Update
	if(storedVersion < MPT_V("1.28.00.39"))
	{
		if(UpdateUpdateCheckPeriod_DEPRECATED <= 0)
		{
			UpdateEnabled = true;
			UpdateIntervalDays = -1;
		} else
		{
			UpdateEnabled = true;
			UpdateIntervalDays = UpdateUpdateCheckPeriod_DEPRECATED.Get();
		}
		const auto url = UpdateUpdateURL_DEPRECATED.Get();
		if(url.empty() ||
		   url == UL_("http://update.openmpt.org/check/$VERSION/$GUID") ||
		   url == UL_("https://update.openmpt.org/check/$VERSION/$GUID"))
		{
			UpdateChannel = UpdateChannelRelease;
		} else if(url == UL_("http://update.openmpt.org/check/testing/$VERSION/$GUID") ||
		          url == UL_("https://update.openmpt.org/check/testing/$VERSION/$GUID"))
		{
			UpdateChannel = UpdateChannelDevelopment;
		} else
		{
			UpdateChannel = UpdateChannelDevelopment;
		}
		UpdateStatistics = UpdateSendGUID_DEPRECATED.Get();
		conf.Forget(UpdateUpdateCheckPeriod_DEPRECATED.GetPath());
		conf.Forget(UpdateUpdateURL_DEPRECATED.GetPath());
		conf.Forget(UpdateSendGUID_DEPRECATED.GetPath());
	}
#endif // MPT_ENABLE_UPDATE

	if(storedVersion < MPT_V("1.29.00.39"))
	{
		// ASIO device IDs are now normalized to upper-case in the device enumeration code.
		// Previous device IDs could be mixed-case (as retrieved from the registry), which would make direct ID comparison fail now.
		auto device = m_SoundDeviceIdentifier.Get();
		if(device.substr(0, 5) == UL_("ASIO_"))
		{
			device = mpt::ToUpperCase(device);
			m_SoundDeviceIdentifier = device;
		}
	}

	// Effects
#ifndef NO_EQ
	FixupEQ(m_EqSettings);
	FixupEQ(m_EqUserPresets[0]);
	FixupEQ(m_EqUserPresets[1]);
	FixupEQ(m_EqUserPresets[2]);
	FixupEQ(m_EqUserPresets[3]);
#endif // !NO_EQ

	// Zxx Macros
	if((MPT_V("1.17.00.00") <= storedVersion) && (storedVersion < MPT_V("1.20.00.00")))
	{
		// Fix old nasty broken (non-standard) MIDI configs in INI file.
		macros.UpgradeMacros();
	}
	theApp.SetDefaultMidiMacro(macros);

	// Paths
	m_szKbdFile = theApp.PathInstallRelativeToAbsolute(m_szKbdFile);

	// Sample undo buffer size (used to be a hidden, absolute setting in MiB)
	int64 oldUndoSize = m_SampleUndoBufferSize.Get().GetSizeInPercent();
	if(storedVersion < MPT_V("1.22.07.25") && oldUndoSize != SampleUndoBufferSize::defaultSize && oldUndoSize != 0)
	{
		m_SampleUndoBufferSize = SampleUndoBufferSize(static_cast<int32>(100 * (oldUndoSize << 20) / SampleUndoBufferSize(100).GetSizeInBytes()));
	}

	// More controls in the plugin selection dialog
	if(storedVersion < MPT_V("1.26.00.26"))
	{
		gnPlugWindowHeight += 40;
	}

	// Sanitize resampling mode for sample editor
	if(!Resampling::IsKnownMode(sampleEditorDefaultResampler) && sampleEditorDefaultResampler != SRCMODE_DEFAULT)
	{
		sampleEditorDefaultResampler = SRCMODE_DEFAULT;
	}

	// Migrate Tuning data
	MigrateTunings(storedVersion);

	// Sanitize MIDI import data
	if(midiImportPatternLen < 1 || midiImportPatternLen > MAX_PATTERN_ROWS)
		midiImportPatternLen = 128;
	if(midiImportQuantize < 4 || midiImportQuantize > 256)
		midiImportQuantize = 32;
	if(midiImportTicks < 2 || midiImportTicks > 16)
		midiImportTicks = 16;

	// Last fixup: update config version
	IniVersion = mpt::ufmt::val(Version::Current());

	// Write updated settings
	conf.Flush();
}


TrackerSettings::~TrackerSettings()
{
	return;
}


namespace SoundDevice
{
namespace Legacy
{
SoundDevice::Info FindDeviceInfo(SoundDevice::Manager &manager, SoundDevice::Legacy::ID id)
{
	if(manager.GetDeviceInfos().empty())
	{
		return SoundDevice::Info();
	}
	SoundDevice::Type type = SoundDevice::Type();
	switch((id & SoundDevice::Legacy::MaskType) >> SoundDevice::Legacy::ShiftType)
	{
		case SoundDevice::Legacy::TypeWAVEOUT:
			type = SoundDevice::TypeWAVEOUT;
			break;
		case SoundDevice::Legacy::TypeDSOUND:
			type = SoundDevice::TypeDSOUND;
			break;
		case SoundDevice::Legacy::TypeASIO:
			type = SoundDevice::TypeASIO;
			break;
		case SoundDevice::Legacy::TypePORTAUDIO_WASAPI:
			type = SoundDevice::TypePORTAUDIO_WASAPI;
			break;
		case SoundDevice::Legacy::TypePORTAUDIO_WDMKS:
			type = SoundDevice::TypePORTAUDIO_WDMKS;
			break;
		case SoundDevice::Legacy::TypePORTAUDIO_WMME:
			type = SoundDevice::TypePORTAUDIO_WMME;
			break;
		case SoundDevice::Legacy::TypePORTAUDIO_DS:
			type = SoundDevice::TypePORTAUDIO_DS;
			break;
	}
	if(type.empty())
	{	// fallback to first device
		return *manager.begin();
	}
	std::size_t index = static_cast<uint8>((id & SoundDevice::Legacy::MaskIndex) >> SoundDevice::Legacy::ShiftIndex);
	std::size_t seenDevicesOfDesiredType = 0;
	for(const auto &info : manager)
	{
		if(info.type == type)
		{
			if(seenDevicesOfDesiredType == index)
			{
				if(!info.IsValid())
				{	// fallback to first device
					return *manager.begin();
				}
				return info;
			}
			seenDevicesOfDesiredType++;
		}
	}
	// default to first device
	return *manager.begin();
}
} // namespace Legacy
} // namespace SoundDevice


void TrackerSettings::MigrateOldSoundDeviceSettings(SoundDevice::Manager &manager)
{
	if(m_SoundDeviceSettingsUseOldDefaults)
	{
		// get the old default device
		SetSoundDeviceIdentifier(SoundDevice::Legacy::FindDeviceInfo(manager, m_SoundDeviceID_DEPRECATED).GetIdentifier());
		// apply old global sound device settings to each found device
		for(const auto &it : manager)
		{
			SetSoundDeviceSettings(it.GetIdentifier(), GetSoundDeviceSettingsDefaults());
		}
	}
}


void TrackerSettings::MigrateTunings(const Version storedVersion)
{
	if(!PathTunings.GetDefaultDir().IsDirectory())
	{
		CreateDirectory(PathTunings.GetDefaultDir().AsNative().c_str(), 0);
	}
	if(!(PathTunings.GetDefaultDir() + P_("Built-in\\")).IsDirectory())
	{
		CreateDirectory((PathTunings.GetDefaultDir() + P_("Built-in\\")).AsNative().c_str(), 0);
	}
	if(!(PathTunings.GetDefaultDir() + P_("Locale\\")).IsDirectory())
	{
		CreateDirectory((PathTunings.GetDefaultDir() + P_("Local\\")).AsNative().c_str(), 0);
	}
	{
		mpt::PathString fn = PathTunings.GetDefaultDir() + P_("Built-in\\12TET.tun");
		if(!fn.FileOrDirectoryExists())
		{
			std::unique_ptr<CTuning> pT = CSoundFile::CreateTuning12TET(U_("12TET"));
			mpt::SafeOutputFile sf(fn, std::ios::binary, mpt::FlushMode::Full);
			pT->Serialize(sf);
		}
	}
	{
		mpt::PathString fn = PathTunings.GetDefaultDir() + P_("Built-in\\12TET [[fs15 1.17.02.49]].tun");
		if(!fn.FileOrDirectoryExists())
		{
			std::unique_ptr<CTuning> pT = CSoundFile::CreateTuning12TET(U_("12TET [[fs15 1.17.02.49]]"));
			mpt::SafeOutputFile sf(fn, std::ios::binary, mpt::FlushMode::Full);
			pT->Serialize(sf);
		}
	}
	oldLocalTunings = LoadLocalTunings();
	if(storedVersion < MPT_V("1.27.00.56"))
	{
		UnpackTuningCollection(*oldLocalTunings, PathTunings.GetDefaultDir() + P_("Local\\"));
	}
}


std::unique_ptr<CTuningCollection> TrackerSettings::LoadLocalTunings()
{
	std::unique_ptr<CTuningCollection> s_pTuningsSharedLocal = std::make_unique<CTuningCollection>();
	mpt::ifstream f(
			PathTunings.GetDefaultDir()
			+ P_("local_tunings")
			+ mpt::PathString::FromUTF8(CTuningCollection::s_FileExtension)
		, std::ios::binary);
	if(f.good())
	{
		mpt::ustring dummyName;
		s_pTuningsSharedLocal->Deserialize(f, dummyName, TuningCharsetFallback);
	}
	return s_pTuningsSharedLocal;
}


struct StoredSoundDeviceSettings
{

private:
	SettingsContainer &conf;
	const SoundDevice::Info deviceInfo;

private:
	Setting<uint32> LatencyUS;
	Setting<uint32> UpdateIntervalUS;
	Setting<uint32> Samplerate;
	Setting<uint8> ChannelsOld; // compatibility with older versions
	Setting<SoundDevice::ChannelMapping> ChannelMapping;
	Setting<uint8> InputChannels;
	Setting<SampleFormat> sampleFormat;
	Setting<bool> ExclusiveMode;
	Setting<bool> BoostThreadPriority;
	Setting<bool> KeepDeviceRunning;
	Setting<bool> UseHardwareTiming;
	Setting<int32> DitherType;
	Setting<uint32> InputSourceID;

public:

	StoredSoundDeviceSettings(SettingsContainer &conf, const SoundDevice::Info & deviceInfo, const SoundDevice::Settings & defaults)
		: conf(conf)
		, deviceInfo(deviceInfo)
		, LatencyUS(conf, U_("Sound Settings"), deviceInfo.GetIdentifier() + U_("_") + U_("Latency"), mpt::saturate_round<int32>(defaults.Latency * 1000000.0))
		, UpdateIntervalUS(conf, U_("Sound Settings"), deviceInfo.GetIdentifier() + U_("_") + U_("UpdateInterval"), mpt::saturate_round<int32>(defaults.UpdateInterval * 1000000.0))
		, Samplerate(conf, U_("Sound Settings"), deviceInfo.GetIdentifier() + U_("_") + U_("SampleRate"), defaults.Samplerate)
		, ChannelsOld(conf, U_("Sound Settings"), deviceInfo.GetIdentifier() + U_("_") + U_("Channels"), mpt::saturate_cast<uint8>((int)defaults.Channels))
		, ChannelMapping(conf, U_("Sound Settings"), deviceInfo.GetIdentifier() + U_("_") + U_("ChannelMapping"), defaults.Channels)
		, InputChannels(conf, U_("Sound Settings"), deviceInfo.GetIdentifier() + U_("_") + U_("InputChannels"), defaults.InputChannels)
		, sampleFormat(conf, U_("Sound Settings"), deviceInfo.GetIdentifier() + U_("_") + U_("SampleFormat"), defaults.sampleFormat)
		, ExclusiveMode(conf, U_("Sound Settings"), deviceInfo.GetIdentifier() + U_("_") + U_("ExclusiveMode"), defaults.ExclusiveMode)
		, BoostThreadPriority(conf, U_("Sound Settings"), deviceInfo.GetIdentifier() + U_("_") + U_("BoostThreadPriority"), defaults.BoostThreadPriority)
		, KeepDeviceRunning(conf, U_("Sound Settings"), deviceInfo.GetIdentifier() + U_("_") + U_("KeepDeviceRunning"), defaults.KeepDeviceRunning)
		, UseHardwareTiming(conf, U_("Sound Settings"), deviceInfo.GetIdentifier() + U_("_") + U_("UseHardwareTiming"), defaults.UseHardwareTiming)
		, DitherType(conf, U_("Sound Settings"), deviceInfo.GetIdentifier() + U_("_") + U_("DitherType"), static_cast<int32>(defaults.DitherType))
		, InputSourceID(conf, U_("Sound Settings"), deviceInfo.GetIdentifier() + U_("_") + U_("InputSourceID"), defaults.InputSourceID)
	{
		if(ChannelMapping.Get().GetNumHostChannels() != ChannelsOld)
		{
			// If the stored channel count and the count of channels used in the channel mapping do not match,
			// construct a default mapping from the channel count.
			ChannelMapping = SoundDevice::ChannelMapping(ChannelsOld);
		}
		// store informational data (not read back, just to allow the user to mock with the raw ini file)
		conf.Write(U_("Sound Settings"), deviceInfo.GetIdentifier() + U_("_") + U_("Type"), deviceInfo.type);
		conf.Write(U_("Sound Settings"), deviceInfo.GetIdentifier() + U_("_") + U_("InternalID"), deviceInfo.internalID);
		conf.Write(U_("Sound Settings"), deviceInfo.GetIdentifier() + U_("_") + U_("API"), deviceInfo.apiName);
		conf.Write(U_("Sound Settings"), deviceInfo.GetIdentifier() + U_("_") + U_("Name"), deviceInfo.name);
	}

	StoredSoundDeviceSettings & operator = (const SoundDevice::Settings &settings)
	{
		LatencyUS = mpt::saturate_round<int32>(settings.Latency * 1000000.0);
		UpdateIntervalUS = mpt::saturate_round<int32>(settings.UpdateInterval * 1000000.0);
		Samplerate = settings.Samplerate;
		ChannelsOld = mpt::saturate_cast<uint8>((int)settings.Channels);
		ChannelMapping = settings.Channels;
		InputChannels = settings.InputChannels;
		sampleFormat = settings.sampleFormat;
		ExclusiveMode = settings.ExclusiveMode;
		BoostThreadPriority = settings.BoostThreadPriority;
		KeepDeviceRunning = settings.KeepDeviceRunning;
		UseHardwareTiming = settings.UseHardwareTiming;
		DitherType = static_cast<int32>(settings.DitherType);
		InputSourceID = settings.InputSourceID;
		return *this;
	}

	operator SoundDevice::Settings () const
	{
		SoundDevice::Settings settings;
		settings.Latency = LatencyUS / 1000000.0;
		settings.UpdateInterval = UpdateIntervalUS / 1000000.0;
		settings.Samplerate = Samplerate;
		settings.Channels = ChannelMapping;
		settings.InputChannels = InputChannels;
		settings.sampleFormat = sampleFormat;
		settings.ExclusiveMode = ExclusiveMode;
		settings.BoostThreadPriority = BoostThreadPriority;
		settings.KeepDeviceRunning = KeepDeviceRunning;
		settings.UseHardwareTiming = UseHardwareTiming;
		settings.DitherType = DitherType;
		settings.InputSourceID = InputSourceID;
		return settings;
	}
};

SoundDevice::Settings TrackerSettings::GetSoundDeviceSettingsDefaults() const
{
	return m_SoundDeviceSettingsDefaults;
}

SoundDevice::Identifier TrackerSettings::GetSoundDeviceIdentifier() const
{
	return m_SoundDeviceIdentifier;
}

void TrackerSettings::SetSoundDeviceIdentifier(const SoundDevice::Identifier &identifier)
{
	m_SoundDeviceIdentifier = identifier;
}

SoundDevice::Settings TrackerSettings::GetSoundDeviceSettings(const SoundDevice::Identifier &device) const
{
	const SoundDevice::Info deviceInfo = theApp.GetSoundDevicesManager()->FindDeviceInfo(device);
	if(!deviceInfo.IsValid())
	{
		return SoundDevice::Settings();
	}
	const SoundDevice::Caps deviceCaps = theApp.GetSoundDevicesManager()->GetDeviceCaps(device, CMainFrame::GetMainFrame()->gpSoundDevice);
	SoundDevice::Settings settings = StoredSoundDeviceSettings(conf, deviceInfo, deviceCaps.DefaultSettings);
	return settings;
}

void TrackerSettings::SetSoundDeviceSettings(const SoundDevice::Identifier &device, const SoundDevice::Settings &settings)
{
	const SoundDevice::Info deviceInfo = theApp.GetSoundDevicesManager()->FindDeviceInfo(device);
	if(!deviceInfo.IsValid())
	{
		return;
	}
	const SoundDevice::Caps deviceCaps = theApp.GetSoundDevicesManager()->GetDeviceCaps(device, CMainFrame::GetMainFrame()->gpSoundDevice);
	StoredSoundDeviceSettings(conf, deviceInfo, deviceCaps.DefaultSettings) = settings;
}


MixerSettings TrackerSettings::GetMixerSettings() const
{
	MixerSettings settings;
	settings.m_nMaxMixChannels = MixerMaxChannels;
	settings.DSPMask = MixerDSPMask;
	settings.MixerFlags = MixerFlags;
	settings.gdwMixingFreq = MixerSamplerate;
	settings.gnChannels = MixerOutputChannels;
	settings.m_nPreAmp = MixerPreAmp;
	settings.m_nStereoSeparation = MixerStereoSeparation;
	settings.VolumeRampUpMicroseconds = MixerVolumeRampUpMicroseconds;
	settings.VolumeRampDownMicroseconds = MixerVolumeRampDownMicroseconds;
	settings.NumInputChannels = MixerNumInputChannels;
	return settings;
}

void TrackerSettings::SetMixerSettings(const MixerSettings &settings)
{
	MixerMaxChannels = settings.m_nMaxMixChannels;
	MixerDSPMask = settings.DSPMask;
	MixerFlags = settings.MixerFlags;
	MixerSamplerate = settings.gdwMixingFreq;
	MixerOutputChannels = settings.gnChannels;
	MixerPreAmp = settings.m_nPreAmp;
	MixerStereoSeparation = settings.m_nStereoSeparation;
	MixerVolumeRampUpMicroseconds = settings.VolumeRampUpMicroseconds;
	MixerVolumeRampDownMicroseconds = settings.VolumeRampDownMicroseconds;
	MixerNumInputChannels = static_cast<uint32>(settings.NumInputChannels);
}


CResamplerSettings TrackerSettings::GetResamplerSettings() const
{
	CResamplerSettings settings;
	settings.SrcMode = ResamplerMode;
	settings.gbWFIRType = ResamplerSubMode;
	settings.gdWFIRCutoff = ResamplerCutoffPercent * 0.01;
	settings.emulateAmiga = ResamplerEmulateAmiga;
	return settings;
}

void TrackerSettings::SetResamplerSettings(const CResamplerSettings &settings)
{
	ResamplerMode = settings.SrcMode;
	ResamplerSubMode = settings.gbWFIRType;
	ResamplerCutoffPercent = mpt::saturate_round<int32>(settings.gdWFIRCutoff * 100.0);
	ResamplerEmulateAmiga = settings.emulateAmiga;
}


void TrackerSettings::GetDefaultColourScheme(std::array<COLORREF, MAX_MODCOLORS> &colours)
{
	colours[MODCOLOR_BACKNORMAL] = RGB(0xFF, 0xFF, 0xFF);
	colours[MODCOLOR_TEXTNORMAL] = RGB(0x00, 0x00, 0x00);
	colours[MODCOLOR_BACKCURROW] = RGB(0xC0, 0xC0, 0xC0);
	colours[MODCOLOR_TEXTCURROW] = RGB(0x00, 0x00, 0x00);
	colours[MODCOLOR_BACKSELECTED] = RGB(0x00, 0x00, 0x00);
	colours[MODCOLOR_TEXTSELECTED] = RGB(0xFF, 0xFF, 0xFF);
	colours[MODCOLOR_SAMPLE] = RGB(0xFF, 0x00, 0x00);
	colours[MODCOLOR_BACKPLAYCURSOR] = RGB(0xFF, 0xFF, 0x80);
	colours[MODCOLOR_TEXTPLAYCURSOR] = RGB(0x00, 0x00, 0x00);
	colours[MODCOLOR_BACKHILIGHT] = RGB(0xE0, 0xE8, 0xE0);
	// Effect Colors
	colours[MODCOLOR_NOTE] = RGB(0x00, 0x00, 0x80);
	colours[MODCOLOR_INSTRUMENT] = RGB(0x00, 0x80, 0x80);
	colours[MODCOLOR_VOLUME] = RGB(0x00, 0x80, 0x00);
	colours[MODCOLOR_PANNING] = RGB(0x00, 0x80, 0x80);
	colours[MODCOLOR_PITCH] = RGB(0x80, 0x80, 0x00);
	colours[MODCOLOR_GLOBALS] = RGB(0x80, 0x00, 0x00);
	// VU-Meters
	colours[MODCOLOR_VUMETER_LO] = RGB(0x00, 0xC8, 0x00);
	colours[MODCOLOR_VUMETER_MED] = RGB(0xFF, 0xC8, 0x00);
	colours[MODCOLOR_VUMETER_HI] = RGB(0xE1, 0x00, 0x00);
	colours[MODCOLOR_VUMETER_LO_VST] = RGB(0x18, 0x96, 0xE1);
	colours[MODCOLOR_VUMETER_MED_VST] = RGB(0xFF, 0xC8, 0x00);
	colours[MODCOLOR_VUMETER_HI_VST] = RGB(0xE1, 0x00, 0x00);
	// Channel separators
	colours[MODCOLOR_SEPSHADOW] = GetSysColor(COLOR_BTNSHADOW);
	colours[MODCOLOR_SEPFACE] = GetSysColor(COLOR_BTNFACE);
	colours[MODCOLOR_SEPHILITE] = GetSysColor(COLOR_BTNHIGHLIGHT);
	// Pattern blend colour
	colours[MODCOLOR_BLENDCOLOR] = GetSysColor(COLOR_BTNFACE);
	// Dodgy commands
	colours[MODCOLOR_DODGY_COMMANDS] = RGB(0xC0, 0x00, 0x00);
	// Sample / instrument editor
	colours[MODCOLOR_BACKSAMPLE] = RGB(0x00, 0x00, 0x00);
	colours[MODCOLOR_SAMPLESELECTED] = RGB(0xFF, 0xFF, 0xFF);
	colours[MODCOLOR_BACKENV] = RGB(0x00, 0x00, 0x00);
	colours[MODCOLOR_ENVELOPES] = RGB(0x00, 0x00, 0xFF);
	colours[MODCOLOR_ENVELOPE_RELEASE] = RGB(0xFF, 0xFF, 0x00);
	colours[MODCOLOR_SAMPLE_LOOPMARKER] = RGB(0x30, 0xCC, 0x30);
	colours[MODCOLOR_SAMPLE_SUSTAINMARKER] = RGB(50, 0xCC, 0xCC);
	colours[MODCOLOR_SAMPLE_CUEPOINT] = RGB(0xFF, 0xCC, 0x30);
}


#ifndef NO_EQ

void TrackerSettings::FixupEQ(EQPreset &eqSettings)
{
	for(UINT i = 0; i < MAX_EQ_BANDS; i++)
	{
		if(eqSettings.Gains[i] > 32)
			eqSettings.Gains[i] = 16;
		if((eqSettings.Freqs[i] < 100) || (eqSettings.Freqs[i] > 10000))
			eqSettings.Freqs[i] = FlatEQPreset.Freqs[i];
	}
	mpt::String::SetNullTerminator(eqSettings.szName);
}

#endif // !NO_EQ


void TrackerSettings::SaveSettings()
{

	WINDOWPLACEMENT wpl;
	wpl.length = sizeof(WINDOWPLACEMENT);
	CMainFrame::GetMainFrame()->GetWindowPlacement(&wpl);
	conf.Write<WINDOWPLACEMENT>(U_("Display"), U_("WindowPlacement"), wpl);

	conf.Write<int32>(U_("Pattern Editor"), U_("NumClipboards"), mpt::saturate_cast<int32>(PatternClipboard::GetClipboardSize()));

	// Effects
#ifndef NO_DSP
	conf.Write<int32>(U_("Effects"), U_("XBassDepth"), m_MegaBassSettings.m_nXBassDepth);
	conf.Write<int32>(U_("Effects"), U_("XBassRange"), m_MegaBassSettings.m_nXBassRange);
#endif
#ifndef NO_REVERB
	conf.Write<int32>(U_("Effects"), U_("ReverbDepth"), m_ReverbSettings.m_nReverbDepth);
	conf.Write<int32>(U_("Effects"), U_("ReverbType"), m_ReverbSettings.m_nReverbType);
#endif
#ifndef NO_DSP
	conf.Write<int32>(U_("Effects"), U_("ProLogicDepth"), m_SurroundSettings.m_nProLogicDepth);
	conf.Write<int32>(U_("Effects"), U_("ProLogicDelay"), m_SurroundSettings.m_nProLogicDelay);
#endif
#ifndef NO_EQ
	conf.Write<EQPreset>(U_("Effects"), U_("EQ_Settings"), m_EqSettings);
	conf.Write<EQPreset>(U_("Effects"), U_("EQ_User1"), m_EqUserPresets[0]);
	conf.Write<EQPreset>(U_("Effects"), U_("EQ_User2"), m_EqUserPresets[1]);
	conf.Write<EQPreset>(U_("Effects"), U_("EQ_User3"), m_EqUserPresets[2]);
	conf.Write<EQPreset>(U_("Effects"), U_("EQ_User4"), m_EqUserPresets[3]);
#endif
#ifndef NO_DSP
	conf.Write<int32>(U_("Effects"), U_("BitCrushBits"), m_BitCrushSettings.m_Bits);
#endif

	// Display (Colors)
	for(int ncol = 0; ncol < MAX_MODCOLORS; ncol++)
	{
		conf.Write<uint32>(U_("Display"), MPT_UFORMAT("Color{}")(mpt::ufmt::dec0<2>(ncol)), rgbCustomColors[ncol]);
	}

	// Paths
	// Obsolete, since we always write to Keybindings.mkb now.
	// Older versions of OpenMPT 1.18+ will look for this file if this entry is missing, so removing this entry after having read it is kind of backwards compatible.
	conf.Remove(U_("Paths"), U_("Key_Config_File"));

	// Chords
	SaveChords(Chords);

	// Save default macro configuration
	MIDIMacroConfig macros;
	theApp.GetDefaultMidiMacro(macros);
	for(int isfx = 0; isfx < kSFxMacros; isfx++)
	{
		conf.Write<std::string>(U_("Zxx Macros"), MPT_UFORMAT("SF{}")(mpt::ufmt::HEX(isfx)), macros.SFx[isfx]);
	}
	for(int izxx = 0; izxx < kZxxMacros; izxx++)
	{
		conf.Write<std::string>(U_("Zxx Macros"), MPT_UFORMAT("Z{}")(mpt::ufmt::HEX0<2>(izxx | 0x80)), macros.Zxx[izxx]);
	}

	// MRU list
	for(uint32 i = 0; i < (ID_MRU_LIST_LAST - ID_MRU_LIST_FIRST + 1); i++)
	{
		mpt::ustring key = MPT_UFORMAT("File{}")(i);

		if(i < mruFiles.size())
		{
			mpt::PathString path = mruFiles[i];
			if(theApp.IsPortableMode())
			{
				path = theApp.PathAbsoluteToInstallRelative(path);
			}
			conf.Write<mpt::PathString>(U_("Recent File List"), key, path);
		} else
		{
			conf.Remove(U_("Recent File List"), key);
		}
	}
}


bool TrackerSettings::IsComponentBlocked(const std::string &key)
{
	return Setting<bool>(conf, U_("Components"), U_("Block") + mpt::ToUnicode(mpt::Charset::ASCII, key), ComponentManagerSettingsDefault().IsBlocked(key));
}


std::vector<uint32> TrackerSettings::GetSampleRates() const
{
	return m_SoundSampleRates;
}


std::vector<uint32> TrackerSettings::GetDefaultSampleRates()
{
	return std::vector<uint32>{
		192000,
		176400,
		96000,
		88200,
		48000,
		44100,
		32000,
		24000,
		22050,
		16000,
		11025,
		8000
	};
}


////////////////////////////////////////////////////////////////////////////////
// Chords

void TrackerSettings::LoadChords(MPTChords &chords)
{
	for(std::size_t i = 0; i < std::size(chords); i++)
	{
		uint32 chord;
		mpt::ustring noteName = MPT_UFORMAT("{}{}")(mpt::ustring(NoteNamesSharp[i % 12]), i / 12);
		if((chord = conf.Read<int32>(U_("Chords"), noteName, -1)) != uint32(-1))
		{
			if((chord & 0xFFFFFFC0) || chords[i].notes[0] == MPTChord::noNote)
			{
				chords[i].key = (uint8)(chord & 0x3F);
				int shift = 6;
				for(auto &note : chords[i].notes)
				{
					// Extract 6 bits and sign-extend to 8 bits
					const int signBit = ((chord >> (shift + 5)) & 1);
					note = static_cast<MPTChord::NoteType>(((chord >> shift) & 0x3F) | (0xC0 * signBit));
					shift += 6;
					if(note == 0)
						note = MPTChord::noNote;
					else if(note > 0)
						note--;
				}
			}
		}
	}
}


void TrackerSettings::SaveChords(MPTChords &chords)
{
	for(std::size_t i = 0; i < std::size(chords); i++)
	{
		auto notes = chords[i].notes;
		for(auto &note : notes)
		{
			if(note == MPTChord::noNote)
				note = 0;
			else if(note >= 0)
				note++;
			note &= 0x3F;
		}
		int32 s = (chords[i].key) | (notes[0] << 6) | (notes[1] << 12) | (notes[2] << 18);
		mpt::ustring noteName = MPT_UFORMAT("{}{}")(mpt::ustring(NoteNamesSharp[i % 12]), i / 12);
		conf.Write<int32>(U_("Chords"), noteName, s);
	}
}


void TrackerSettings::SetMIDIDevice(UINT id)
{
	m_nMidiDevice = id;
	MIDIINCAPS mic;
	mic.szPname[0] = 0;
	if(midiInGetDevCaps(id, &mic, sizeof(mic)) == MMSYSERR_NOERROR)
	{
		midiDeviceName = mic.szPname;
	}
}


UINT TrackerSettings::GetCurrentMIDIDevice()
{
	if(midiDeviceName.Get().IsEmpty())
		return m_nMidiDevice;

	CString deviceName = midiDeviceName;
	deviceName.TrimRight();

	MIDIINCAPS mic;
	UINT candidate = m_nMidiDevice, numDevs = midiInGetNumDevs();
	for(UINT i = 0; i < numDevs; i++)
	{
		mic.szPname[0] = 0;
		if(midiInGetDevCaps(i, &mic, sizeof(mic)) != MMSYSERR_NOERROR)
			continue;

		// Some device names have trailing spaces (e.g. "USB MIDI Interface "), but those may get lost in our settings framework.
		mpt::String::SetNullTerminator(mic.szPname);
		size_t strLen = _tcslen(mic.szPname);
		while(strLen-- > 0)
		{
			if(mic.szPname[strLen] == _T(' '))
				mic.szPname[strLen] = 0;
			else
				break;
		}
		if(CString(mic.szPname) == deviceName)
		{
			candidate = i;
			numDevs = m_nMidiDevice + 1;
			// If the same device name exists twice, try to match both device number and name
			if(candidate == m_nMidiDevice)
				return candidate;
		}
	}
	// If the device changed its ID, update it now.
	m_nMidiDevice = candidate;
	return candidate;
}


mpt::ustring IgnoredCCsToString(const std::bitset<128> &midiIgnoreCCs)
{
	mpt::ustring cc;
	bool first = true;
	for(int i = 0; i < 128; i++)
	{
		if(midiIgnoreCCs[i])
		{
			if(!first)
			{
				cc += U_(",");
			}
			cc += mpt::ufmt::val(i);
			first = false;
		}
	}
	return cc;
}


std::bitset<128> StringToIgnoredCCs(const mpt::ustring &in)
{
	CString cc = mpt::ToCString(in);
	std::bitset<128> midiIgnoreCCs;
	midiIgnoreCCs.reset();
	int curPos = 0;
	CString ccToken = cc.Tokenize(_T(", "), curPos);
	while(ccToken != _T(""))
	{
		int ccNumber = ConvertStrTo<int>(ccToken);
		if(ccNumber >= 0 && ccNumber <= 127)
			midiIgnoreCCs.set(ccNumber);
		ccToken = cc.Tokenize(_T(", "), curPos);
	}
	return midiIgnoreCCs;
}


DefaultAndWorkingDirectory::DefaultAndWorkingDirectory()
{
	return;
}

DefaultAndWorkingDirectory::DefaultAndWorkingDirectory(const mpt::PathString &def)
	: m_Default(def)
	, m_Working(def)
{
	return;
}

DefaultAndWorkingDirectory::~DefaultAndWorkingDirectory()
{
	return;
}

void DefaultAndWorkingDirectory::SetDefaultDir(const mpt::PathString &filenameFrom, bool stripFilename)
{
	if(InternalSet(m_Default, filenameFrom, stripFilename) && !m_Default.empty())
	{
		// When updating default directory, also update the working directory.
		InternalSet(m_Working, filenameFrom, stripFilename);
	}
}

void DefaultAndWorkingDirectory::SetWorkingDir(const mpt::PathString &filenameFrom, bool stripFilename)
{
	InternalSet(m_Working, filenameFrom, stripFilename);
}

mpt::PathString DefaultAndWorkingDirectory::GetDefaultDir() const
{
	return m_Default;
}

mpt::PathString DefaultAndWorkingDirectory::GetWorkingDir() const
{
	return m_Working;
}

// Retrieve / set default directory from given string and store it our setup variables
// If stripFilename is true, the filenameFrom parameter is assumed to be a full path including a filename.
// Return true if the value changed.
bool DefaultAndWorkingDirectory::InternalSet(mpt::PathString &dest, const mpt::PathString &filenameFrom, bool stripFilename)
{
	mpt::PathString newPath = (stripFilename ? filenameFrom.GetPath() : filenameFrom);
	newPath.EnsureTrailingSlash();
	mpt::PathString oldPath = dest;
	dest = newPath;
	return newPath != oldPath;
}

ConfigurableDirectory::ConfigurableDirectory(SettingsContainer &conf, const AnyStringLocale &section, const AnyStringLocale &key, const mpt::PathString &def)
	: conf(conf)
	, m_Setting(conf, section, key, def)
{
	SetDefaultDir(theApp.PathInstallRelativeToAbsolute(m_Setting), false);
}

ConfigurableDirectory::~ConfigurableDirectory()
{
	m_Setting = theApp.IsPortableMode() ? theApp.PathAbsoluteToInstallRelative(m_Default) : m_Default;
}



OPENMPT_NAMESPACE_END