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

/*
 * MPDlgs.cpp
 * ----------
 * Purpose: Implementation of various player setup dialogs.
 * Notes  : (currently none)
 * Authors: OpenMPT Devs
 * The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
 */


#include "stdafx.h"
#include "Mptrack.h"
#include "Sndfile.h"
#include "Mainfrm.h"
#include "ImageLists.h"
#include "Moddoc.h"
#include "Mpdlgs.h"
#include "dlg_misc.h"
#include "../common/mptStringBuffer.h"
#include "openmpt/sounddevice/SoundDevice.hpp"
#include "openmpt/sounddevice/SoundDeviceManager.hpp"
#include "../common/Dither.h"


OPENMPT_NAMESPACE_BEGIN


const TCHAR *gszChnCfgNames[3] =
{
	_T("Mono"),
	_T("Stereo"),
	_T("Quad")
};


static double ParseTime(CString str)
{
	return ConvertStrTo<double>(mpt::ToCharset(mpt::Charset::ASCII, str)) / 1000.0;
}


static CString PrintTime(double seconds)
{
	int32 microseconds = mpt::saturate_round<int32>(seconds * 1000000.0);
	int precision = 0;
	if(microseconds < 1000)
	{
		precision = 3;
	} else if(microseconds < 10000)
	{
		precision = 2;
	} else if(microseconds < 100000)
	{
		precision = 1;
	} else
	{
		precision = 0;
	}
	return MPT_CFORMAT("{} ms")(mpt::cfmt::fix(seconds * 1000.0, precision));
}


BEGIN_MESSAGE_MAP(COptionsSoundcard, CPropertyPage)
	ON_WM_HSCROLL()
	ON_COMMAND(IDC_CHECK4,	&COptionsSoundcard::OnExclusiveModeChanged)
	ON_COMMAND(IDC_CHECK5,	&COptionsSoundcard::OnSettingsChanged)
	ON_COMMAND(IDC_CHECK7,	&COptionsSoundcard::OnSettingsChanged)
	ON_COMMAND(IDC_CHECK9,	&COptionsSoundcard::OnSettingsChanged)
	ON_COMMAND(IDC_CHECK_SOUNDCARD_SHOWALL, &COptionsSoundcard::OnSoundCardShowAll)
	ON_CBN_SELCHANGE(IDC_COMBO1, &COptionsSoundcard::OnDeviceChanged)
	ON_CBN_SELCHANGE(IDC_COMBO2, &COptionsSoundcard::OnSettingsChanged)
	ON_CBN_SELCHANGE(IDC_COMBO_UPDATEINTERVAL, &COptionsSoundcard::OnSettingsChanged)
	ON_CBN_SELCHANGE(IDC_COMBO3, &COptionsSoundcard::OnSettingsChanged)
	ON_CBN_SELCHANGE(IDC_COMBO4, &COptionsSoundcard::OnSettingsChanged)
	ON_CBN_SELCHANGE(IDC_COMBO5, &COptionsSoundcard::OnChannelsChanged)
	ON_CBN_SELCHANGE(IDC_COMBO6, &COptionsSoundcard::OnSampleFormatChanged)
	ON_CBN_SELCHANGE(IDC_COMBO10, &COptionsSoundcard::OnSettingsChanged)
	ON_CBN_EDITCHANGE(IDC_COMBO2, &COptionsSoundcard::OnSettingsChanged)
	ON_CBN_EDITCHANGE(IDC_COMBO_UPDATEINTERVAL, &COptionsSoundcard::OnSettingsChanged)
	ON_CBN_SELCHANGE(IDC_COMBO11, &COptionsSoundcard::OnSettingsChanged)
	ON_COMMAND(IDC_BUTTON1,	&COptionsSoundcard::OnSoundCardRescan)
	ON_COMMAND(IDC_BUTTON2,	&COptionsSoundcard::OnSoundCardDriverPanel)
	ON_CBN_SELCHANGE(IDC_COMBO_CHANNEL_FRONTLEFT, &COptionsSoundcard::OnChannel1Changed)
	ON_CBN_SELCHANGE(IDC_COMBO_CHANNEL_FRONTRIGHT, &COptionsSoundcard::OnChannel2Changed)
	ON_CBN_SELCHANGE(IDC_COMBO_CHANNEL_REARLEFT, &COptionsSoundcard::OnChannel3Changed)
	ON_CBN_SELCHANGE(IDC_COMBO_CHANNEL_REARRIGHT, &COptionsSoundcard::OnChannel4Changed)
	ON_CBN_SELCHANGE(IDC_COMBO_RECORDING_CHANNELS, &COptionsSoundcard::OnRecordingChanged)
	ON_CBN_SELCHANGE(IDC_COMBO_RECORDING_SOURCE, &COptionsSoundcard::OnSettingsChanged)
END_MESSAGE_MAP()


void COptionsSoundcard::OnSampleFormatChanged()
{
	OnSettingsChanged();
	UpdateDither();
}


void COptionsSoundcard::OnRecordingChanged()
{
	DWORD_PTR inputChannels = m_CbnRecordingChannels.GetItemData(m_CbnRecordingChannels.GetCurSel());
	m_CbnRecordingSource.EnableWindow((m_CurrentDeviceCaps.HasNamedInputSources && inputChannels > 0) ? TRUE : FALSE);
	OnSettingsChanged();
}


void COptionsSoundcard::DoDataExchange(CDataExchange* pDX)
{
	CPropertyPage::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(COptionsSoundcard)
	DDX_Control(pDX, IDC_COMBO1,		m_CbnDevice);
	DDX_Control(pDX, IDC_COMBO2,		m_CbnLatencyMS);
	DDX_Control(pDX, IDC_COMBO_UPDATEINTERVAL, m_CbnUpdateIntervalMS);
	DDX_Control(pDX, IDC_COMBO3,		m_CbnMixingFreq);
	DDX_Control(pDX, IDC_COMBO5,		m_CbnChannels);
	DDX_Control(pDX, IDC_COMBO6,		m_CbnSampleFormat);
	DDX_Control(pDX, IDC_COMBO10,		m_CbnDither);
	DDX_Control(pDX, IDC_BUTTON2,		m_BtnDriverPanel);
	DDX_Control(pDX, IDC_COMBO6,		m_CbnSampleFormat);
	DDX_Control(pDX, IDC_COMBO11,		m_CbnStoppedMode);
	DDX_Control(pDX, IDC_COMBO_CHANNEL_FRONTLEFT , m_CbnChannelMapping[0]);
	DDX_Control(pDX, IDC_COMBO_CHANNEL_FRONTRIGHT, m_CbnChannelMapping[1]);
	DDX_Control(pDX, IDC_COMBO_CHANNEL_REARLEFT  , m_CbnChannelMapping[2]);
	DDX_Control(pDX, IDC_COMBO_CHANNEL_REARRIGHT , m_CbnChannelMapping[3]);
	DDX_Control(pDX, IDC_COMBO_RECORDING_CHANNELS,		m_CbnRecordingChannels);
	DDX_Control(pDX, IDC_COMBO_RECORDING_SOURCE,		m_CbnRecordingSource);
	DDX_Control(pDX, IDC_EDIT_STATISTICS,	m_EditStatistics);
	//}}AFX_DATA_MAP
}


COptionsSoundcard::COptionsSoundcard(SoundDevice::Identifier deviceIdentifier)
	: CPropertyPage(IDD_OPTIONS_SOUNDCARD)
	, m_InitialDeviceIdentifier(deviceIdentifier)
{
	return;
}


void COptionsSoundcard::SetInitialDevice()
{
	SetDevice(m_InitialDeviceIdentifier, true);
}


void COptionsSoundcard::SetDevice(SoundDevice::Identifier dev, bool forceReload)
{
	SoundDevice::Identifier olddev = m_CurrentDeviceInfo.GetIdentifier();
	SoundDevice::Info newInfo;
	SoundDevice::Caps newCaps;
	SoundDevice::DynamicCaps newDynamicCaps;
	SoundDevice::Settings newSettings;
	newInfo = theApp.GetSoundDevicesManager()->FindDeviceInfo(dev);
	newCaps = theApp.GetSoundDevicesManager()->GetDeviceCaps(dev, CMainFrame::GetMainFrame()->gpSoundDevice);
	newDynamicCaps = theApp.GetSoundDevicesManager()->GetDeviceDynamicCaps(dev, TrackerSettings::Instance().GetSampleRates(), CMainFrame::GetMainFrame(), CMainFrame::GetMainFrame()->gpSoundDevice, true);
	bool deviceChanged = (dev != olddev);
	if(deviceChanged || forceReload)
	{
		newSettings = TrackerSettings::Instance().GetSoundDeviceSettings(dev);
	} else
	{
		newSettings = m_Settings;
	}
	m_CurrentDeviceInfo = newInfo;
	m_CurrentDeviceCaps = newCaps;
	m_CurrentDeviceDynamicCaps = newDynamicCaps;
	m_Settings = newSettings;
}


void COptionsSoundcard::OnSoundCardShowAll()
{
	TrackerSettings::Instance().m_SoundShowDeprecatedDevices = (IsDlgButtonChecked(IDC_CHECK_SOUNDCARD_SHOWALL) == BST_CHECKED);
	SetDevice(m_CurrentDeviceInfo.GetIdentifier(), true);
	UpdateEverything();
}


void COptionsSoundcard::OnSoundCardRescan()
{
	{
		// Close sound device because IDs might change when re-enumerating which could cause all kinds of havoc.
		CMainFrame::GetMainFrame()->audioCloseDevice();
		delete CMainFrame::GetMainFrame()->gpSoundDevice;
		CMainFrame::GetMainFrame()->gpSoundDevice = nullptr;
	}
	theApp.GetSoundDevicesManager()->ReEnumerate();
	SetDevice(m_CurrentDeviceInfo.GetIdentifier(), true);
	UpdateEverything();
}


BOOL COptionsSoundcard::OnInitDialog()
{
	CPropertyPage::OnInitDialog();
	SetInitialDevice();
	UpdateEverything();
	return TRUE;
}


void COptionsSoundcard::UpdateLatency()
{
	{
		GetDlgItem(IDC_STATIC_LATENCY)->EnableWindow(TRUE);
		m_CbnLatencyMS.EnableWindow(TRUE);
	}
	// latency
	{
		static constexpr double latencies [] = {
			0.001,
			0.002,
			0.003,
			0.004,
			0.005,
			0.010,
			0.015,
			0.020,
			0.025,
			0.030,
			0.040,
			0.050,
			0.075,
			0.100,
			0.150,
			0.200,
			0.250
		};
		m_CbnLatencyMS.ResetContent();
		m_CbnLatencyMS.SetWindowText(PrintTime(m_Settings.Latency));
		for(auto lat : latencies)
		{
			if(m_CurrentDeviceCaps.LatencyMin <= lat && lat <= m_CurrentDeviceCaps.LatencyMax)
			{
				m_CbnLatencyMS.AddString(PrintTime(lat));
			}
		}
	}
	if(theApp.GetSoundDevicesManager()->IsDeviceUnavailable(m_CurrentDeviceInfo.GetIdentifier()))
	{
		GetDlgItem(IDC_STATIC_LATENCY)->EnableWindow(FALSE);
		m_CbnLatencyMS.EnableWindow(FALSE);
	}
}


void COptionsSoundcard::UpdateUpdateInterval()
{
	{
		m_CbnUpdateIntervalMS.EnableWindow(TRUE);
	}
	// update interval
	{
		static constexpr double updateIntervals [] = {
			0.001,
			0.002,
			0.005,
			0.010,
			0.015,
			0.020,
			0.025,
			0.050
		};
		m_CbnUpdateIntervalMS.ResetContent();
		m_CbnUpdateIntervalMS.SetWindowText(PrintTime(m_Settings.UpdateInterval));
		for(auto upd : updateIntervals)
		{
			if(m_CurrentDeviceCaps.UpdateIntervalMin <= upd && upd <= m_CurrentDeviceCaps.UpdateIntervalMax)
			{
				m_CbnUpdateIntervalMS.AddString(PrintTime(upd));
			}
		}
	}
	if(theApp.GetSoundDevicesManager()->IsDeviceUnavailable(m_CurrentDeviceInfo.GetIdentifier()) || !m_CurrentDeviceCaps.CanUpdateInterval)
	{
		m_CbnUpdateIntervalMS.EnableWindow(FALSE);
	}
}


void COptionsSoundcard::UpdateGeneral()
{
	// General
	{
		if(m_CurrentDeviceCaps.CanKeepDeviceRunning)
		{
			m_CbnStoppedMode.ResetContent();
			m_CbnStoppedMode.AddString(_T("Close driver"));
			m_CbnStoppedMode.AddString(_T("Pause driver"));
			m_CbnStoppedMode.AddString(_T("Play silence"));
			m_CbnStoppedMode.SetCurSel(TrackerSettings::Instance().m_SoundSettingsStopMode);
		} else
		{
			m_CbnStoppedMode.ResetContent();
			m_CbnStoppedMode.AddString(_T("Close driver"));
			m_CbnStoppedMode.AddString(_T("Close driver"));
			m_CbnStoppedMode.AddString(_T("Close driver"));
			m_CbnStoppedMode.SetCurSel(TrackerSettings::Instance().m_SoundSettingsStopMode);
		}
		CheckDlgButton(IDC_CHECK7, TrackerSettings::Instance().m_SoundSettingsOpenDeviceAtStartup ? BST_CHECKED : BST_UNCHECKED);
	}
	bool isUnavailble = theApp.GetSoundDevicesManager()->IsDeviceUnavailable(m_CurrentDeviceInfo.GetIdentifier());
	m_CbnStoppedMode.EnableWindow(isUnavailble ? FALSE : (m_CurrentDeviceCaps.CanKeepDeviceRunning ? TRUE : FALSE));
	CPropertySheet *sheet = dynamic_cast<CPropertySheet *>(GetParent());
	if(sheet) sheet->GetDlgItem(IDOK)->EnableWindow(isUnavailble ? FALSE : TRUE);
}


void COptionsSoundcard::UpdateEverything()
{
	// Sound Device
	{
		if(m_CurrentDeviceInfo.IsDeprecated())
		{
			TrackerSettings::Instance().m_SoundShowDeprecatedDevices = true;
		}
		CheckDlgButton(IDC_CHECK_SOUNDCARD_SHOWALL, TrackerSettings::Instance().m_SoundShowDeprecatedDevices ? BST_CHECKED : BST_UNCHECKED);

		m_CbnDevice.ResetContent();
		m_CbnDevice.SetImageList(&CMainFrame::GetMainFrame()->m_MiscIcons);

		UINT iItem = 0;

		for(const auto &it : *theApp.GetSoundDevicesManager())
		{

			if(!TrackerSettings::Instance().m_SoundShowDeprecatedDevices)
			{
				if(it.IsDeprecated())
				{
					continue;
				}
			}

			{
				COMBOBOXEXITEM cbi;
				MemsetZero(cbi);
				cbi.iItem = iItem;
				cbi.cchTextMax = 0;
				cbi.mask = CBEIF_LPARAM | CBEIF_TEXT;
				cbi.lParam = theApp.GetSoundDevicesManager()->GetGlobalID(it.GetIdentifier());
				mpt::ustring TypeWineNative = U_("Wine-Native");
				if(it.type == SoundDevice::TypeWAVEOUT || it.type == SoundDevice::TypePORTAUDIO_WMME)
				{
					cbi.mask |= CBEIF_IMAGE | CBEIF_SELECTEDIMAGE | CBEIF_OVERLAY;
					cbi.iImage = IMAGE_WAVEOUT;
				} else if(it.type == SoundDevice::TypeDSOUND || it.type == SoundDevice::TypePORTAUDIO_DS || it.type == U_("RtAudio-ds"))
				{
					cbi.mask |= CBEIF_IMAGE | CBEIF_SELECTEDIMAGE | CBEIF_OVERLAY;
					cbi.iImage = IMAGE_DIRECTX;
				} else if(it.type == SoundDevice::TypeASIO || it.type == U_("RtAudio-asio"))
				{
					cbi.mask |= CBEIF_IMAGE | CBEIF_SELECTEDIMAGE | CBEIF_OVERLAY;
					cbi.iImage = IMAGE_ASIO;
				} else if(it.type == SoundDevice::TypePORTAUDIO_WASAPI || it.type == U_("RtAudio-wasapi"))
				{
					cbi.mask |= CBEIF_IMAGE | CBEIF_SELECTEDIMAGE | CBEIF_OVERLAY;
					cbi.iImage = IMAGE_SAMPLEMUTE; // // No real image available for now,
				} else if(it.type == SoundDevice::TypePORTAUDIO_WDMKS)
				{
					cbi.mask |= CBEIF_IMAGE | CBEIF_SELECTEDIMAGE | CBEIF_OVERLAY;
					cbi.iImage = IMAGE_CHIP; // No real image available for now,
				} else if(it.type.find(TypeWineNative + U_("-")) == 0)
				{
					if(theApp.GetWineVersion() && (theApp.GetWineVersion()->HostClass() == mpt::osinfo::osclass::Linux))
					{
						cbi.mask |= CBEIF_IMAGE | CBEIF_SELECTEDIMAGE | CBEIF_OVERLAY;
						cbi.iImage = IMAGE_TUX;
					} else
					{
						cbi.iImage = 0;
					}
				} else
				{
					cbi.iImage = 0;
				}
				cbi.iSelectedImage = cbi.iImage;
				cbi.iOverlay = cbi.iImage;
				CString tmp = mpt::ToCString(it.GetDisplayName());
				cbi.pszText = const_cast<TCHAR *>(tmp.GetString());
				cbi.iIndent = 0;
				int pos = m_CbnDevice.InsertItem(&cbi);
				if(static_cast<SoundDevice::Manager::GlobalID>(cbi.lParam) == theApp.GetSoundDevicesManager()->GetGlobalID(m_CurrentDeviceInfo.GetIdentifier()))
				{
					m_CbnDevice.SetCurSel(pos);
				}
				iItem++;
			}
		}
	}

	UpdateDevice();

}


void COptionsSoundcard::UpdateDevice()
{
	GetDlgItem(IDC_CHECK_SOUNDCARD_SHOWALL)->EnableWindow(m_CurrentDeviceInfo.IsDeprecated() ? FALSE : TRUE);
	UpdateGeneral();
	UpdateControls();
	UpdateLatency();
	UpdateUpdateInterval();
	UpdateSampleRates();
	UpdateChannels();
	UpdateSampleFormat();
	UpdateDither();
	UpdateChannelMapping();
	UpdateRecording();
}


void COptionsSoundcard::UpdateChannels()
{
	{
		m_CbnChannels.EnableWindow(TRUE);
	}
	m_CbnChannels.ResetContent();
	int maxChannels = 0;
	if(m_CurrentDeviceDynamicCaps.channelNames.size() > 0)
	{
		maxChannels = static_cast<int>(std::min(std::size_t(4), m_CurrentDeviceDynamicCaps.channelNames.size()));
	} else
	{
		maxChannels = 4;
	}
	int sel = 0;
	for(int channels = maxChannels; channels >= 1; channels /= 2)
	{
		int ndx = m_CbnChannels.AddString(gszChnCfgNames[(channels+2)/2-1]);
		m_CbnChannels.SetItemData(ndx, channels);
		if(channels == m_Settings.Channels)
		{
			sel = ndx;
		}
	}
	m_CbnChannels.SetCurSel(sel);
	if(theApp.GetSoundDevicesManager()->IsDeviceUnavailable(m_CurrentDeviceInfo.GetIdentifier()))
	{
		m_CbnChannels.EnableWindow(FALSE);
	}
}


void COptionsSoundcard::UpdateRecording()
{
	GetDlgItem(IDC_STATIC_RECORDING)->ShowWindow(TrackerSettings::Instance().m_SoundShowRecordingSettings ? SW_SHOW : SW_HIDE);
	m_CbnRecordingChannels.ShowWindow(TrackerSettings::Instance().m_SoundShowRecordingSettings ? SW_SHOW : SW_HIDE);
	m_CbnRecordingSource.ShowWindow(TrackerSettings::Instance().m_SoundShowRecordingSettings ? SW_SHOW : SW_HIDE);
	m_CbnRecordingChannels.ResetContent();
	m_CbnRecordingSource.ResetContent();
	if(m_CurrentDeviceCaps.CanInput && ((m_CurrentDeviceCaps.HasNamedInputSources && m_CurrentDeviceDynamicCaps.inputSourceNames.size() > 0) || !m_CurrentDeviceCaps.HasNamedInputSources))
	{
		GetDlgItem(IDC_STATIC_RECORDING)->EnableWindow(TRUE);
		m_CbnRecordingChannels.EnableWindow(TRUE);
		int sel = 0;
		{
			int ndx = m_CbnRecordingChannels.AddString(_T("off"));
			m_CbnRecordingChannels.SetItemData(ndx, 0);
			if(0 == m_Settings.InputChannels)
			{
				sel = ndx;
			}
		}
		for(int channels = 4; channels >= 1; channels /= 2)
		{
			int ndx = m_CbnRecordingChannels.AddString(gszChnCfgNames[(channels+2)/2-1]);
			m_CbnRecordingChannels.SetItemData(ndx, channels);
			if(channels == m_Settings.InputChannels)
			{
				sel = ndx;
			}
		}
		m_CbnRecordingChannels.SetCurSel(sel);
		if(m_CurrentDeviceCaps.HasNamedInputSources)
		{
			m_CbnRecordingSource.EnableWindow((m_Settings.InputChannels > 0) ? TRUE : FALSE);
			sel = -1;
			for(size_t ch = 0; ch < m_CurrentDeviceDynamicCaps.inputSourceNames.size(); ch++)
			{
				const int pos = (int)::SendMessageW(m_CbnRecordingSource.m_hWnd, CB_ADDSTRING, 0, (LPARAM)m_CurrentDeviceDynamicCaps.inputSourceNames[ch].second.c_str());
				m_CbnRecordingSource.SetItemData(pos, (DWORD_PTR)m_CurrentDeviceDynamicCaps.inputSourceNames[ch].first);
				if(m_CurrentDeviceDynamicCaps.inputSourceNames[ch].first == m_Settings.InputSourceID)
				{
					sel = pos;
				}
			}
			if(sel == -1 ) sel = 0;
			m_CbnRecordingSource.SetCurSel(sel);
		} else
		{
			m_CbnRecordingSource.EnableWindow(FALSE);
		}
	} else
	{
		GetDlgItem(IDC_STATIC_RECORDING)->EnableWindow(FALSE);
		m_CbnRecordingChannels.EnableWindow(FALSE);
		int ndx = m_CbnRecordingChannels.AddString(_T("off"));
		m_CbnRecordingChannels.SetItemData(ndx, 0);
		m_CbnRecordingChannels.SetCurSel(ndx);
		m_CbnRecordingSource.EnableWindow(FALSE);
	}
}


void COptionsSoundcard::UpdateSampleFormat()
{
	{
		m_CbnSampleFormat.EnableWindow(TRUE);
	}
	UINT n = 0;
	m_CbnSampleFormat.ResetContent();
	std::vector<SampleFormat> sampleformats;
	if(IsDlgButtonChecked(IDC_CHECK4))
	{
		sampleformats = m_CurrentDeviceDynamicCaps.supportedExclusiveModeSampleFormats;
	} else
	{
		sampleformats = m_CurrentDeviceDynamicCaps.supportedSampleFormats;
	}
	m_CbnSampleFormat.EnableWindow(m_CurrentDeviceCaps.CanSampleFormat && (sampleformats.size() != 1) ? TRUE : FALSE);
	const std::vector<SampleFormat> allSampleFormats = AllSampleFormats<std::vector<SampleFormat>>();
	for(const auto sampleFormat : allSampleFormats)
	{
		if(!sampleformats.empty() && !mpt::contains(sampleformats, sampleFormat))
		{
			continue;
		}
		CString name;
		if(sampleFormat.IsFloat())
		{
			name = MPT_CFORMAT("Float {} bit")(sampleFormat.GetBitsPerSample());
		} else if(sampleFormat.IsUnsigned())
		{
			name = MPT_CFORMAT("{} Bit uint")(sampleFormat.GetBitsPerSample());
		} else
		{
			name = MPT_CFORMAT("{} Bit")(sampleFormat.GetBitsPerSample());
		}
		UINT ndx = m_CbnSampleFormat.AddString(name);
		m_CbnSampleFormat.SetItemData(ndx, mpt::to_underlying<SampleFormat::Enum>(sampleFormat));
		if(sampleFormat == m_Settings.sampleFormat)
		{
			n = ndx;
		}
	}
	m_CbnSampleFormat.SetCurSel(n);
	if(theApp.GetSoundDevicesManager()->IsDeviceUnavailable(m_CurrentDeviceInfo.GetIdentifier()))
	{
		m_CbnSampleFormat.EnableWindow(FALSE);
	}
}


void COptionsSoundcard::UpdateDither()
{
	{
		m_CbnDither.EnableWindow(TRUE);
	}
	m_CbnDither.ResetContent();
	SampleFormat sampleFormat = SampleFormat::FromInt(static_cast<int>(m_CbnSampleFormat.GetItemData(m_CbnSampleFormat.GetCurSel())));
	if(sampleFormat.IsInt() && sampleFormat.GetBitsPerSample() < 32)
	{
		m_CbnDither.EnableWindow(TRUE);
		for(std::size_t i = 0; i < DithersOpenMPT::GetNumDithers(); ++i)
		{
			m_CbnDither.AddString(mpt::ToCString(DithersOpenMPT::GetModeName(i) + U_(" dither")));
		}
	} else if(m_CurrentDeviceCaps.HasInternalDither)
	{
		m_CbnDither.EnableWindow(TRUE);
		m_CbnDither.AddString(mpt::ToCString(DithersOpenMPT::GetModeName(DithersOpenMPT::GetNoDither()) + U_(" dither")));
		m_CbnDither.AddString(mpt::ToCString(DithersOpenMPT::GetModeName(DithersOpenMPT::GetDefaultDither()) + U_(" dither")));
	} else
	{
		m_CbnDither.EnableWindow(FALSE);
		for(std::size_t i = 0; i < DithersOpenMPT::GetNumDithers(); ++i)
		{
			m_CbnDither.AddString(mpt::ToCString(DithersOpenMPT::GetModeName(DithersOpenMPT::GetNoDither()) + U_(" dither")));
		}
	}
	if(m_Settings.DitherType < 0 || m_Settings.DitherType >= m_CbnDither.GetCount())
	{
		m_CbnDither.SetCurSel(1);
	} else
	{
		m_CbnDither.SetCurSel(m_Settings.DitherType);
	}
	if(theApp.GetSoundDevicesManager()->IsDeviceUnavailable(m_CurrentDeviceInfo.GetIdentifier()))
	{
		m_CbnDither.EnableWindow(FALSE);
	}
}


void COptionsSoundcard::UpdateChannelMapping()
{
	{
		GetDlgItem(IDC_STATIC_CHANNELMAPPING)->EnableWindow(TRUE);
		GetDlgItem(IDC_STATIC_CHANNEL_FRONT)->EnableWindow(TRUE);
		GetDlgItem(IDC_STATIC_CHANNEL_REAR)->EnableWindow(TRUE);
		for(int mch = 0; mch < NUM_CHANNELCOMBOBOXES; mch++)
		{
			CComboBox *combo = &m_CbnChannelMapping[mch];
			combo->EnableWindow(TRUE);
		}
	}
	int usedChannels = static_cast<int>(m_CbnChannels.GetItemData(m_CbnChannels.GetCurSel()));
	if(m_Settings.Channels.GetNumHostChannels() != static_cast<uint32>(usedChannels))
	{
		// If the channel mapping is not valid for the selected number of channels, reset it to default identity mapping.
		m_Settings.Channels = SoundDevice::ChannelMapping(usedChannels);
	}
	GetDlgItem(IDC_STATIC_CHANNELMAPPING)->EnableWindow(m_CurrentDeviceCaps.CanChannelMapping ? TRUE : FALSE);
	if(m_CurrentDeviceCaps.CanChannelMapping && usedChannels > 2)
	{
		GetDlgItem(IDC_STATIC_CHANNEL_FRONT)->EnableWindow(TRUE);
		GetDlgItem(IDC_STATIC_CHANNEL_REAR)->EnableWindow(TRUE);
	} else
	{
		GetDlgItem(IDC_STATIC_CHANNEL_FRONT)->EnableWindow(FALSE);
		GetDlgItem(IDC_STATIC_CHANNEL_REAR)->EnableWindow(FALSE);
	}
	for(int mch = 0; mch < NUM_CHANNELCOMBOBOXES; mch++)	// Host channels
	{
		CComboBox *combo = &m_CbnChannelMapping[mch];
		combo->EnableWindow((m_CurrentDeviceCaps.CanChannelMapping && mch < usedChannels) ? TRUE : FALSE);
		combo->ResetContent();
		if(m_CurrentDeviceCaps.CanChannelMapping)
		{
			combo->SetItemData(combo->AddString(_T("Unassigned")), (DWORD_PTR)-1);
			combo->SetCurSel(0);
			if(mch < usedChannels)
			{
				for(size_t dch = 0; dch < m_CurrentDeviceDynamicCaps.channelNames.size(); dch++)	// Device channels
				{
					const int pos = (int)::SendMessageW(combo->m_hWnd, CB_ADDSTRING, 0, (LPARAM)m_CurrentDeviceDynamicCaps.channelNames[dch].c_str());
					combo->SetItemData(pos, (DWORD_PTR)dch);
					if(static_cast<int32>(dch) == m_Settings.Channels.ToDevice(mch))
					{
						combo->SetCurSel(pos);
					}
				}
			}
		}
	}
	if(theApp.GetSoundDevicesManager()->IsDeviceUnavailable(m_CurrentDeviceInfo.GetIdentifier()))
	{
		GetDlgItem(IDC_STATIC_CHANNELMAPPING)->EnableWindow(FALSE);
		GetDlgItem(IDC_STATIC_CHANNEL_FRONT)->EnableWindow(FALSE);
		GetDlgItem(IDC_STATIC_CHANNEL_REAR)->EnableWindow(FALSE);
		for(int mch = 0; mch < NUM_CHANNELCOMBOBOXES; mch++)
		{
			CComboBox *combo = &m_CbnChannelMapping[mch];
			combo->EnableWindow(FALSE);
		}
	}
}


void COptionsSoundcard::OnDeviceChanged()
{
	int n = m_CbnDevice.GetCurSel();
	if(n >= 0)
	{
		SetDevice(theApp.GetSoundDevicesManager()->FindDeviceInfo(static_cast<SoundDevice::Manager::GlobalID>(m_CbnDevice.GetItemData(n))).GetIdentifier());
		UpdateDevice();
		OnSettingsChanged();
	}
}


void COptionsSoundcard::OnExclusiveModeChanged()
{
	UpdateSampleRates();
	UpdateSampleFormat();
	UpdateDither();
	OnSettingsChanged();
}


void COptionsSoundcard::OnChannelsChanged()
{
	UpdateChannelMapping();
	OnSettingsChanged();
}


void COptionsSoundcard::OnSoundCardDriverPanel()
{
	theApp.GetSoundDevicesManager()->OpenDriverSettings(
		theApp.GetSoundDevicesManager()->FindDeviceInfo(static_cast<SoundDevice::Manager::GlobalID>(m_CbnDevice.GetItemData(m_CbnDevice.GetCurSel()))).GetIdentifier(),
		CMainFrame::GetMainFrame(),
		CMainFrame::GetMainFrame()->gpSoundDevice
		);
}


void COptionsSoundcard::OnChannelChanged(int channel)
{
	CComboBox *combo = &m_CbnChannelMapping[channel];
	const LONG_PTR newChn = combo->GetItemData(combo->GetCurSel());
	if(newChn == -1)
	{
		return;
	}
	// Ensure that no channel is used twice
	for(int mch = 0; mch < NUM_CHANNELCOMBOBOXES; mch++)	// Host channels
	{
		if(mch != channel)
		{
			combo = &m_CbnChannelMapping[mch];
			if((int)combo->GetItemData(combo->GetCurSel()) == newChn)
			{
				// find an unused channel
				bool found = false;
				int deviceChannel = 0;
				for(; deviceChannel < static_cast<int>(m_CurrentDeviceDynamicCaps.channelNames.size()); ++deviceChannel)
				{
					bool used = false;
					for(int hostChannel = 0; hostChannel < NUM_CHANNELCOMBOBOXES; ++hostChannel)
					{
						if(static_cast<int>(m_CbnChannelMapping[hostChannel].GetItemData(m_CbnChannelMapping[hostChannel].GetCurSel())) == deviceChannel)
						{
							used = true;
							break;
						}
					}
					if(!used)
					{
						found = true;
						break;
					}
				}
				if(found)
				{
					combo->SetCurSel(deviceChannel+1);
				} else
				{
					combo->SetCurSel(0);
				}
				break;
			}
		}
	}
	OnSettingsChanged();
}


// Fill the dropdown box with a list of valid sample rates, depending on the selected sound device.
void COptionsSoundcard::UpdateSampleRates()
{
	{
		GetDlgItem(IDC_STATIC_FORMAT)->EnableWindow(TRUE);
		m_CbnMixingFreq.EnableWindow(TRUE);
	}

	m_CbnMixingFreq.ResetContent();

	std::vector<uint32> samplerates;

	if(IsDlgButtonChecked(IDC_CHECK4))
	{
		samplerates = m_CurrentDeviceDynamicCaps.supportedExclusiveSampleRates;
	} else
	{
		samplerates = m_CurrentDeviceDynamicCaps.supportedSampleRates;
	}

	if(samplerates.empty())
	{
		// We have no valid list of supported playback rates! Assume all rates supported by OpenMPT are possible...
		samplerates = TrackerSettings::Instance().GetSampleRates();
	}

	int n = 0;
	for(size_t i = 0; i < samplerates.size(); i++)
	{
		int pos = m_CbnMixingFreq.AddString(MPT_CFORMAT("{} Hz")(samplerates[i]));
		m_CbnMixingFreq.SetItemData(pos, samplerates[i]);
		if(m_Settings.Samplerate == samplerates[i])
		{
			n = pos;
		}
	}
	m_CbnMixingFreq.SetCurSel(n);
	if(theApp.GetSoundDevicesManager()->IsDeviceUnavailable(m_CurrentDeviceInfo.GetIdentifier()))
	{
		GetDlgItem(IDC_STATIC_FORMAT)->EnableWindow(FALSE);
		m_CbnMixingFreq.EnableWindow(FALSE);
	}
}


void COptionsSoundcard::UpdateControls()
{
	{
		m_BtnDriverPanel.EnableWindow(TRUE);
		GetDlgItem(IDC_CHECK4)->EnableWindow(TRUE);
		GetDlgItem(IDC_CHECK5)->EnableWindow(TRUE);
		GetDlgItem(IDC_CHECK9)->EnableWindow(TRUE);
		GetDlgItem(IDC_STATIC_UPDATEINTERVAL)->EnableWindow(TRUE);
		GetDlgItem(IDC_COMBO_UPDATEINTERVAL)->EnableWindow(TRUE);
	}
	if(!m_CurrentDeviceCaps.CanKeepDeviceRunning)
	{
		m_Settings.KeepDeviceRunning = false;
	}
	m_BtnDriverPanel.EnableWindow(m_CurrentDeviceCaps.CanDriverPanel ? TRUE : FALSE);
	GetDlgItem(IDC_CHECK4)->EnableWindow(m_CurrentDeviceCaps.CanExclusiveMode ? TRUE : FALSE);
	GetDlgItem(IDC_CHECK5)->EnableWindow(m_CurrentDeviceCaps.CanBoostThreadPriority ? TRUE : FALSE);
	GetDlgItem(IDC_CHECK9)->EnableWindow(m_CurrentDeviceCaps.CanUseHardwareTiming ? TRUE : FALSE);
	GetDlgItem(IDC_STATIC_UPDATEINTERVAL)->EnableWindow(m_CurrentDeviceCaps.CanUpdateInterval ? TRUE : FALSE);
	GetDlgItem(IDC_COMBO_UPDATEINTERVAL)->EnableWindow(m_CurrentDeviceCaps.CanUpdateInterval ? TRUE : FALSE);
	GetDlgItem(IDC_CHECK4)->SetWindowText(mpt::ToCString(m_CurrentDeviceCaps.ExclusiveModeDescription));
	CheckDlgButton(IDC_CHECK4, m_CurrentDeviceCaps.CanExclusiveMode && m_Settings.ExclusiveMode ? BST_CHECKED : BST_UNCHECKED);
	CheckDlgButton(IDC_CHECK5, m_CurrentDeviceCaps.CanBoostThreadPriority && m_Settings.BoostThreadPriority ? BST_CHECKED : BST_UNCHECKED);
	CheckDlgButton(IDC_CHECK9, m_CurrentDeviceCaps.CanUseHardwareTiming && m_Settings.UseHardwareTiming ? BST_CHECKED : BST_UNCHECKED);
	if(theApp.GetSoundDevicesManager()->IsDeviceUnavailable(m_CurrentDeviceInfo.GetIdentifier()))
	{
		m_BtnDriverPanel.EnableWindow(FALSE);
		GetDlgItem(IDC_CHECK4)->EnableWindow(FALSE);
		GetDlgItem(IDC_CHECK5)->EnableWindow(FALSE);
		GetDlgItem(IDC_CHECK9)->EnableWindow(FALSE);
		GetDlgItem(IDC_STATIC_UPDATEINTERVAL)->EnableWindow(FALSE);
		GetDlgItem(IDC_COMBO_UPDATEINTERVAL)->EnableWindow(FALSE);
	}
}


BOOL COptionsSoundcard::OnSetActive()
{
	CMainFrame::m_nLastOptionsPage = OPTIONS_PAGE_SOUNDCARD;
	return CPropertyPage::OnSetActive();
}


void COptionsSoundcard::OnOK()
{
	if(!theApp.GetSoundDevicesManager()->IsDeviceUnavailable(m_CurrentDeviceInfo.GetIdentifier()))
	{

	// General
	{
		TrackerSettings::Instance().m_SoundSettingsOpenDeviceAtStartup = IsDlgButtonChecked(IDC_CHECK7) != BST_UNCHECKED;
	}
	m_Settings.ExclusiveMode = IsDlgButtonChecked(IDC_CHECK4) != BST_UNCHECKED;
	m_Settings.BoostThreadPriority = IsDlgButtonChecked(IDC_CHECK5) != BST_UNCHECKED;
	m_Settings.UseHardwareTiming = IsDlgButtonChecked(IDC_CHECK9) != BST_UNCHECKED;
	// Mixing Freq
	{
		m_Settings.Samplerate = static_cast<uint32>(m_CbnMixingFreq.GetItemData(m_CbnMixingFreq.GetCurSel()));
	}
	// Channels
	{
		DWORD_PTR n = m_CbnChannels.GetItemData(m_CbnChannels.GetCurSel());
		m_Settings.Channels = static_cast<int>(n);
		if((m_Settings.Channels != 1) && (m_Settings.Channels != 4))
		{
			m_Settings.Channels = 2;
		}
	}
	// SampleFormat
	{
		DWORD_PTR n = m_CbnSampleFormat.GetItemData(m_CbnSampleFormat.GetCurSel());
		m_Settings.sampleFormat = SampleFormat::FromInt(static_cast<int>(n));
	}
	// Dither
	{
		m_Settings.DitherType = m_CbnDither.GetCurSel();
	}
	// Latency
	{
		CString s;
		m_CbnLatencyMS.GetWindowText(s);
		m_Settings.Latency = ParseTime(s);
		//Check given value.
		if(m_Settings.Latency == 0.0) m_Settings.Latency = m_CurrentDeviceCaps.DefaultSettings.Latency;
		m_Settings.Latency = Clamp(m_Settings.Latency, m_CurrentDeviceCaps.LatencyMin, m_CurrentDeviceCaps.LatencyMax);
		m_CbnLatencyMS.SetWindowText(PrintTime(m_Settings.Latency));
	}
	// Update Interval
	{
		CString s;
		m_CbnUpdateIntervalMS.GetWindowText(s);
		m_Settings.UpdateInterval = ParseTime(s);
		//Check given value.
		if(m_Settings.UpdateInterval == 0.0) m_Settings.UpdateInterval = m_CurrentDeviceCaps.DefaultSettings.UpdateInterval;
		m_Settings.UpdateInterval = Clamp(m_Settings.UpdateInterval, m_CurrentDeviceCaps.UpdateIntervalMin, m_CurrentDeviceCaps.UpdateIntervalMax);
		m_CbnUpdateIntervalMS.SetWindowText(PrintTime(m_Settings.UpdateInterval));
	}
	// Channel Mapping
	{
		if(m_CurrentDeviceCaps.CanChannelMapping)
		{
			int numChannels = std::min(static_cast<int>(m_Settings.Channels), static_cast<int>(NUM_CHANNELCOMBOBOXES));
			std::vector<int32> channels(numChannels);
			for(int mch = 0; mch < numChannels; mch++)	// Host channels
			{
				CComboBox *combo = &m_CbnChannelMapping[mch];
				channels[mch] = static_cast<int32>(combo->GetItemData(combo->GetCurSel()));
			}
			m_Settings.Channels = channels;
		}
	}
	// Recording
	{
		if(TrackerSettings::Instance().m_SoundShowRecordingSettings && m_CurrentDeviceCaps.CanInput && ((m_CurrentDeviceCaps.HasNamedInputSources && m_CurrentDeviceDynamicCaps.inputSourceNames.size() > 0) || !m_CurrentDeviceCaps.HasNamedInputSources))
		{
			DWORD_PTR n = m_CbnRecordingChannels.GetItemData(m_CbnRecordingChannels.GetCurSel());
			m_Settings.InputChannels = static_cast<uint8>(n);
			if((m_Settings.InputChannels != 1) && (m_Settings.InputChannels != 2) && (m_Settings.InputChannels != 4))
			{
				m_Settings.InputChannels = 0;
			}
			if(m_CurrentDeviceCaps.HasNamedInputSources)
			{
				DWORD_PTR sourceID = m_CbnRecordingSource.GetItemData(m_CbnRecordingSource.GetCurSel());
				m_Settings.InputSourceID = static_cast<uint32>(sourceID);
			} else
			{
				m_Settings.InputSourceID = 0;
			}
		} else
		{
			m_Settings.InputChannels = 0;
			m_Settings.InputSourceID = 0;
		}
	}
	CMainFrame::GetMainFrame()->SetupSoundCard(m_Settings, m_CurrentDeviceInfo.GetIdentifier(), (SoundDeviceStopMode)m_CbnStoppedMode.GetCurSel());
	SetDevice(m_CurrentDeviceInfo.GetIdentifier(), true); // Poll changed ASIO sample format and channel names
	UpdateDevice();
	UpdateStatistics();

	} else
	{

		Reporting::Error("Sound card currently not available.");

	}

	CPropertyPage::OnOK();
}


void COptionsSoundcard::UpdateStatistics()
{
	if (!m_EditStatistics) return;
	CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
	if(pMainFrm->gpSoundDevice && pMainFrm->IsPlaying())
	{
		const SoundDevice::BufferAttributes bufferAttributes = pMainFrm->gpSoundDevice->GetEffectiveBufferAttributes();
		const SoundDevice::Statistics stats = pMainFrm->gpSoundDevice->GetStatistics();
#if 0
		const SoundDevice::TimeInfo timeInfo = pMainFrm->gpSoundDevice->GetTimeInfo();
		const SoundDevice::StreamPosition streamPosition = pMainFrm->gpSoundDevice->GetStreamPosition();
#endif
		const uint32 samplerate = pMainFrm->gpSoundDevice->GetSettings().Samplerate;
		mpt::ustring s;
		if(bufferAttributes.NumBuffers > 2)
		{
			s += MPT_UFORMAT("Buffer: {}% ({}/{})\r\n")((bufferAttributes.Latency > 0.0) ? mpt::saturate_round<int64>(stats.InstantaneousLatency / bufferAttributes.Latency * 100.0) : 0, (stats.LastUpdateInterval > 0.0) ? mpt::saturate_round<int64>(bufferAttributes.Latency / stats.LastUpdateInterval) : 0, bufferAttributes.NumBuffers);
		} else
		{
			s += MPT_UFORMAT("Buffer: {}%\r\n")((bufferAttributes.Latency > 0.0) ? mpt::saturate_round<int64>(stats.InstantaneousLatency / bufferAttributes.Latency * 100.0) : 0);
		}
		s += MPT_UFORMAT("Latency: {} ms (current: {} ms, {} frames)\r\n")(mpt::ufmt::fix(bufferAttributes.Latency * 1000.0, 1), mpt::ufmt::fix(stats.InstantaneousLatency * 1000.0, 1), mpt::saturate_round<int64>(stats.InstantaneousLatency * samplerate));
		s += MPT_UFORMAT("Period: {} ms (current: {} ms, {} frames)\r\n")(mpt::ufmt::fix(bufferAttributes.UpdateInterval * 1000.0, 1), mpt::ufmt::fix(stats.LastUpdateInterval * 1000.0, 1), mpt::saturate_round<int64>(stats.LastUpdateInterval * samplerate));
#if 0
		s += MPT_UFORMAT("TimeInfo: latency = {} ms / speed = {} / latency = {} ms\r\n")(
			mpt::ufmt::fix(timeInfo.Latency * 1000.0, 1),
			mpt::ufmt::flt(timeInfo.Speed, 4),
			mpt::ufmt::fix((timeInfo.RenderStreamPositionBefore.Seconds - streamPosition.Seconds) * 1000.0, 1));
#endif
		s += stats.text;
		m_EditStatistics.SetWindowText(mpt::ToCString(s));
	}	else
	{
		if(theApp.GetSoundDevicesManager()->IsDeviceUnavailable(m_CurrentDeviceInfo.GetIdentifier()))
		{
			m_EditStatistics.SetWindowText(_T("Device currently unavailable."));
		} else
		{
			m_EditStatistics.SetWindowText(_T(""));
		}
	}
}


//////////////////
// COptionsMixer

BEGIN_MESSAGE_MAP(COptionsMixer, CPropertyPage)
	ON_WM_HSCROLL()
	ON_WM_VSCROLL()
	ON_CBN_SELCHANGE(IDC_COMBO_FILTER,     &COptionsMixer::OnSettingsChanged)
	ON_CBN_SELCHANGE(IDC_COMBO_AMIGA_TYPE, &COptionsMixer::OnSettingsChanged)
	ON_EN_UPDATE(IDC_RAMPING_IN,           &COptionsMixer::OnRampingChanged)
	ON_EN_UPDATE(IDC_RAMPING_OUT,          &COptionsMixer::OnRampingChanged)
	ON_COMMAND(IDC_CHECK_SOFTPAN,          &COptionsMixer::OnSettingsChanged)
	ON_COMMAND(IDC_CHECK1,                 &COptionsMixer::OnAmigaChanged)
	ON_COMMAND(IDC_BUTTON1,                &COptionsMixer::OnDefaultRampSettings)
END_MESSAGE_MAP()


void COptionsMixer::DoDataExchange(CDataExchange* pDX)
{
	CPropertyPage::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(COptionsSoundcard)
	DDX_Control(pDX, IDC_COMBO_FILTER, m_CbnResampling);
	DDX_Control(pDX, IDC_COMBO_AMIGA_TYPE, m_CbnAmigaType);
	DDX_Control(pDX, IDC_RAMPING_IN, m_CEditRampUp);
	DDX_Control(pDX, IDC_RAMPING_OUT, m_CEditRampDown);
	DDX_Control(pDX, IDC_EDIT_VOLRAMP_SAMPLES_UP, m_CInfoRampUp);
	DDX_Control(pDX, IDC_EDIT_VOLRAMP_SAMPLES_DOWN, m_CInfoRampDown);
	DDX_Control(pDX, IDC_SLIDER_STEREOSEP, m_SliderStereoSep);
	// check box soft pan
	DDX_Control(pDX, IDC_SLIDER_PREAMP, m_SliderPreAmp);
	//}}AFX_DATA_MAP
}


BOOL COptionsMixer::OnInitDialog()
{
	CPropertyPage::OnInitDialog();

	// Resampling type
	{
		const auto resamplingModes = Resampling::AllModes();
		for(auto mode : resamplingModes)
		{
			int index = m_CbnResampling.AddString(CTrackApp::GetResamplingModeName(mode, 2, true));
			m_CbnResampling.SetItemData(index, mode);
			if(TrackerSettings::Instance().ResamplerMode == mode)
			{
				m_CbnResampling.SetCurSel(index);
			}
		}
	}

	// Amiga Resampler
	const bool enableAmigaResampler = TrackerSettings::Instance().ResamplerEmulateAmiga != Resampling::AmigaFilter::Off;
	CheckDlgButton(IDC_CHECK1, enableAmigaResampler ? BST_CHECKED : BST_UNCHECKED);
	m_CbnAmigaType.EnableWindow(enableAmigaResampler ? TRUE : FALSE);
	static constexpr std::pair<const TCHAR *, Resampling::AmigaFilter> Filters[] =
	{
		{_T("A500 Filter"),  Resampling::AmigaFilter::A500},
		{_T("A1200 Filter"), Resampling::AmigaFilter::A1200},
		{_T("Unfiltered"),   Resampling::AmigaFilter::Unfiltered},
	};
	int sel = 0;
	for(const auto & [name, filter] : Filters)
	{
		const int item = m_CbnAmigaType.AddString(name);
		m_CbnAmigaType.SetItemData(item, static_cast<DWORD_PTR>(filter));
		if(filter == TrackerSettings::Instance().ResamplerEmulateAmiga)
			sel = item;
	}
	m_CbnAmigaType.SetCurSel(sel);

	// volume ramping
	{
		m_CEditRampUp.SetWindowText(mpt::ToCString(mpt::ufmt::val(TrackerSettings::Instance().GetMixerSettings().GetVolumeRampUpMicroseconds())));
		m_CEditRampDown.SetWindowText(mpt::ToCString(mpt::ufmt::val(TrackerSettings::Instance().GetMixerSettings().GetVolumeRampDownMicroseconds())));
		static_cast<CSpinButtonCtrl *>(GetDlgItem(IDC_SPIN2))->SetRange32(0, int32_max);
		static_cast<CSpinButtonCtrl *>(GetDlgItem(IDC_SPIN3))->SetRange32(0, int32_max);
		UpdateRamping();
	}

	// Stereo Separation
	{
		m_SliderStereoSep.SetRange(0, 32);
		m_SliderStereoSep.SetPos(16);
		for (int n = 0; n <= 32; n++)
		{
			if ((int)TrackerSettings::Instance().MixerStereoSeparation <= 8 * n)
			{
				m_SliderStereoSep.SetPos(n);
				break;
			}
		}
		UpdateStereoSep();
	}

	// soft pan
	{
		CheckDlgButton(IDC_CHECK_SOFTPAN, (TrackerSettings::Instance().MixerFlags & SNDMIX_SOFTPANNING) ? BST_CHECKED : BST_UNCHECKED);
	}

	// Pre-Amplification
	{
		m_SliderPreAmp.SetTicFreq(5);
		m_SliderPreAmp.SetRange(0, 40);
		int n = (TrackerSettings::Instance().MixerPreAmp - 64) / 8;
		if ((n < 0) || (n > 40)) n = 16;
		m_SliderPreAmp.SetPos(n);
	}

	m_initialized = true;

	return TRUE;
}


BOOL COptionsMixer::OnSetActive()
{
	CMainFrame::m_nLastOptionsPage = OPTIONS_PAGE_MIXER;
	return CPropertyPage::OnSetActive();
}


void COptionsMixer::OnAmigaChanged()
{
	const bool enableAmigaResampler = IsDlgButtonChecked(IDC_CHECK1) != BST_UNCHECKED;
	m_CbnAmigaType.EnableWindow(enableAmigaResampler ? TRUE : FALSE);
	OnSettingsChanged();
}


void COptionsMixer::OnRampingChanged()
{
	if(!m_initialized)
		return;
	UpdateRamping();
	OnSettingsChanged();
}


void COptionsMixer::OnDefaultRampSettings()
{
	m_CEditRampUp.SetWindowText(mpt::ToCString(mpt::ufmt::val(MixerSettings().GetVolumeRampUpMicroseconds())));
	m_CEditRampDown.SetWindowText(mpt::ToCString(mpt::ufmt::val(MixerSettings().GetVolumeRampDownMicroseconds())));
	OnRampingChanged();
}


void COptionsMixer::OnHScroll(UINT n, UINT pos, CScrollBar *p)
{
	CPropertyPage::OnHScroll(n, pos, p);
	if(p == (CScrollBar *)&m_SliderStereoSep)
	{
		UpdateStereoSep();
		OnSettingsChanged();
	}
}


void COptionsMixer::UpdateRamping()
{
	MixerSettings settings = TrackerSettings::Instance().GetMixerSettings();
	CString s;
	m_CEditRampUp.GetWindowText(s);
	settings.SetVolumeRampUpMicroseconds(ConvertStrTo<int32>(s));
	m_CEditRampDown.GetWindowText(s);
	settings.SetVolumeRampDownMicroseconds(ConvertStrTo<int32>(s));
	s.Format(_T("%i samples at %i Hz"), (int)settings.GetVolumeRampUpSamples(), (int)settings.gdwMixingFreq);
	m_CInfoRampUp.SetWindowText(s);
	s.Format(_T("%i samples at %i Hz"), (int)settings.GetVolumeRampDownSamples(), (int)settings.gdwMixingFreq);
	m_CInfoRampDown.SetWindowText(s);
}


void COptionsMixer::UpdateStereoSep()
{
	CString s;
	s.Format(_T("%d%%"), ((8 * m_SliderStereoSep.GetPos()) * 100) / 128);
	SetDlgItemText(IDC_TEXT_STEREOSEP, s);
}


void COptionsMixer::OnOK()
{
	// resampler mode
	{
		TrackerSettings::Instance().ResamplerMode = static_cast<ResamplingMode>(m_CbnResampling.GetItemData(m_CbnResampling.GetCurSel()));
	}

	// Amiga Resampler
	if(IsDlgButtonChecked(IDC_CHECK1) == BST_UNCHECKED)
		TrackerSettings::Instance().ResamplerEmulateAmiga = Resampling::AmigaFilter::Off;
	else
		TrackerSettings::Instance().ResamplerEmulateAmiga = static_cast<Resampling::AmigaFilter>(m_CbnAmigaType.GetItemData(m_CbnAmigaType.GetCurSel()));

	// volume ramping
	{
		MixerSettings settings = TrackerSettings::Instance().GetMixerSettings();
		CString s;
		m_CEditRampUp.GetWindowText(s);
		settings.SetVolumeRampUpMicroseconds(ConvertStrTo<int>(s));
		m_CEditRampDown.GetWindowText(s);
		settings.SetVolumeRampDownMicroseconds(ConvertStrTo<int>(s));
		TrackerSettings::Instance().SetMixerSettings(settings);
	}

	// stereo sep
	{
		TrackerSettings::Instance().MixerStereoSeparation = 8 * m_SliderStereoSep.GetPos();
	}

	// soft pan
	{
		if(IsDlgButtonChecked(IDC_CHECK_SOFTPAN))
		{
			TrackerSettings::Instance().MixerFlags = TrackerSettings::Instance().MixerFlags | SNDMIX_SOFTPANNING;
		} else
		{
			TrackerSettings::Instance().MixerFlags = TrackerSettings::Instance().MixerFlags & ~SNDMIX_SOFTPANNING;
		}
	}

	// pre amp
	{
		int n = m_SliderPreAmp.GetPos();
		if ((n >= 0) && (n <= 40)) // approximately +/- 10dB
		{
			TrackerSettings::Instance().MixerPreAmp = 64 + (n * 8);
		}
	}

	CMainFrame::GetMainFrame()->SetupPlayer();
	CMainFrame::GetMainFrame()->PostMessage(WM_MOD_INVALIDATEPATTERNS, HINT_MPTOPTIONS);

	CPropertyPage::OnOK();
}


////////////////////////////////////////////////////////////////////////////////
//
// CEQSavePresetDlg
//

#ifndef NO_EQ

class CEQSavePresetDlg: public CDialog
{
protected:
	EQPreset &m_EQ;

public:
	CEQSavePresetDlg(EQPreset &eq, CWnd *parent = nullptr) : CDialog(IDD_SAVEPRESET, parent), m_EQ(eq) { }
	BOOL OnInitDialog();
	void OnOK();
};


BOOL CEQSavePresetDlg::OnInitDialog()
{
	CComboBox *pCombo = (CComboBox *)GetDlgItem(IDC_COMBO1);
	if (pCombo)
	{
		int ndx = 0;
		for (UINT i=0; i<4; i++)
		{
			int n = pCombo->AddString(mpt::ToCString(mpt::Charset::Locale, TrackerSettings::Instance().m_EqUserPresets[i].szName));
			pCombo->SetItemData( n, i);
			if (!lstrcmpiA(TrackerSettings::Instance().m_EqUserPresets[i].szName, m_EQ.szName)) ndx = n;
		}
		pCombo->SetCurSel(ndx);
	}
	SetDlgItemText(IDC_EDIT1, mpt::ToCString(mpt::Charset::Locale, m_EQ.szName));
	return TRUE;
}


void CEQSavePresetDlg::OnOK()
{
	CComboBox *pCombo = (CComboBox *)GetDlgItem(IDC_COMBO1);
	if (pCombo)
	{
		int n = pCombo->GetCurSel();
		if ((n < 0) || (n >= 4)) n = 0;
		CString s;
		GetDlgItemText(IDC_EDIT1, s);
		mpt::String::WriteAutoBuf(m_EQ.szName) = mpt::ToCharset(mpt::Charset::Locale, s);
		TrackerSettings::Instance().m_EqUserPresets[n] = m_EQ;
	}
	CDialog::OnOK();
}


void CEQSlider::Init(UINT nID, UINT n, CWnd *parent)
{
	m_nSliderNo = n;
	m_pParent = parent;
	SubclassDlgItem(nID, parent);
}


BOOL CEQSlider::PreTranslateMessage(MSG *pMsg)
{
	if ((pMsg) && (pMsg->message == WM_RBUTTONDOWN) && (m_pParent))
	{
		m_x = LOWORD(pMsg->lParam);
		m_y = HIWORD(pMsg->lParam);
		m_pParent->PostMessage(WM_COMMAND, ID_EQSLIDER_BASE+m_nSliderNo, 0);
	}
	return CSliderCtrl::PreTranslateMessage(pMsg);
}

#endif // !NO_EQ


//////////////////////////////////////////////////////////
// COptionsPlayer - DSP / EQ settings


#ifndef NO_EQ
#define EQ_MAX_FREQS	5

const UINT gEqBandFreqs[MAX_EQ_BANDS][EQ_MAX_FREQS] =
{
	{ 100, 125, 150, 200, 250 },
	{ 300, 350, 400, 450, 500 },
	{ 600, 700, 800, 900, 1000 },
	{ 1250, 1500, 1750, 2000, 2500 },
	{ 3000, 3500, 4000, 4500, 5000 },
	{ 6000, 7000, 8000, 9000, 10000 },
};
#endif // !NO_EQ

BEGIN_MESSAGE_MAP(COptionsPlayer, CPropertyPage)
#ifndef NO_EQ
	// EQ
	ON_WM_VSCROLL()
	ON_COMMAND(IDC_CHECK3,	&COptionsPlayer::OnSettingsChanged)
	ON_COMMAND(IDC_BUTTON1,	&COptionsPlayer::OnEqUser1)
	ON_COMMAND(IDC_BUTTON2,	&COptionsPlayer::OnEqUser2)
	ON_COMMAND(IDC_BUTTON3,	&COptionsPlayer::OnEqUser3)
	ON_COMMAND(IDC_BUTTON4,	&COptionsPlayer::OnEqUser4)
	ON_COMMAND(IDC_BUTTON5,	&COptionsPlayer::OnSavePreset)
	ON_COMMAND_RANGE(ID_EQSLIDER_BASE, ID_EQSLIDER_BASE + MAX_EQ_BANDS,	&COptionsPlayer::OnSliderMenu)
	ON_COMMAND_RANGE(ID_EQMENU_BASE, ID_EQMENU_BASE + EQ_MAX_FREQS,		&COptionsPlayer::OnSliderFreq)
#endif // !NO_EQ

	// DSP
	ON_WM_HSCROLL()
	ON_CBN_SELCHANGE(IDC_COMBO2,	&COptionsPlayer::OnSettingsChanged)
	ON_COMMAND(IDC_CHECK1,			&COptionsPlayer::OnSettingsChanged)
	ON_COMMAND(IDC_CHECK2,			&COptionsPlayer::OnSettingsChanged)
	ON_COMMAND(IDC_CHECK4,			&COptionsPlayer::OnSettingsChanged)
	ON_COMMAND(IDC_CHECK5,			&COptionsPlayer::OnSettingsChanged)
	ON_COMMAND(IDC_CHECK6,			&COptionsPlayer::OnSettingsChanged)
	ON_COMMAND(IDC_CHECK7,			&COptionsPlayer::OnSettingsChanged)
END_MESSAGE_MAP()


void COptionsPlayer::DoDataExchange(CDataExchange* pDX)
{
	CPropertyPage::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(COptionsPlayer)
	DDX_Control(pDX, IDC_COMBO2,		m_CbnReverbPreset);
	DDX_Control(pDX, IDC_SLIDER1,		m_SbXBassDepth);
	DDX_Control(pDX, IDC_SLIDER2,		m_SbXBassRange);
	DDX_Control(pDX, IDC_SLIDER3,		m_SbReverbDepth);
	DDX_Control(pDX, IDC_SLIDER5,		m_SbSurroundDepth);
	DDX_Control(pDX, IDC_SLIDER6,		m_SbSurroundDelay);
	DDX_Control(pDX, IDC_SLIDER4,		m_SbBitCrushBits);
	//}}AFX_DATA_MAP
}


BOOL COptionsPlayer::OnInitDialog()
{
	CPropertyPage::OnInitDialog();

	uint32 dwQuality = TrackerSettings::Instance().MixerDSPMask;

#ifndef NO_EQ
	for (UINT i = 0; i < MAX_EQ_BANDS; i++)
	{
		m_Sliders[i].Init(IDC_SLIDER7 + i, i, this);
		m_Sliders[i].SetRange(0, 32);
		m_Sliders[i].SetTicFreq(4);
	}

	UpdateDialog();

	if (dwQuality & SNDDSP_EQ) CheckDlgButton(IDC_CHECK3, BST_CHECKED);
#else
	GetDlgItem(IDC_CHECK3)->EnableWindow(FALSE);
#endif

	// Effects
#ifndef NO_DSP
	if (dwQuality & SNDDSP_MEGABASS) CheckDlgButton(IDC_CHECK1, BST_CHECKED);
#else
	GetDlgItem(IDC_CHECK1)->EnableWindow(FALSE);
#endif
#ifndef NO_AGC
	if (dwQuality & SNDDSP_AGC) CheckDlgButton(IDC_CHECK2, BST_CHECKED);
#else
	GetDlgItem(IDC_CHECK2)->EnableWindow(FALSE);
#endif
#ifndef NO_DSP
	if (dwQuality & SNDDSP_SURROUND) CheckDlgButton(IDC_CHECK4, BST_CHECKED);
#else
	GetDlgItem(IDC_CHECK4)->EnableWindow(FALSE);
#endif
#ifndef NO_DSP
	if (dwQuality & SNDDSP_BITCRUSH) CheckDlgButton(IDC_CHECK5, BST_CHECKED);
#else
	GetDlgItem(IDC_CHECK5)->EnableWindow(FALSE);
#endif

#ifndef NO_DSP
	m_SbBitCrushBits.SetRange(1, 24);
	m_SbBitCrushBits.SetPos(TrackerSettings::Instance().m_BitCrushSettings.m_Bits);
#else
	m_SbBitCurshBits.EnableWindow(FALSE);
#endif

#ifndef NO_DSP
	// Bass Expansion
	m_SbXBassDepth.SetRange(0,4);
	m_SbXBassDepth.SetPos(8-TrackerSettings::Instance().m_MegaBassSettings.m_nXBassDepth);
	m_SbXBassRange.SetRange(0,4);
	m_SbXBassRange.SetPos(4 - (TrackerSettings::Instance().m_MegaBassSettings.m_nXBassRange - 1) / 5);
#else
	m_SbXBassDepth.EnableWindow(FALSE);
	m_SbXBassRange.EnableWindow(FALSE);
#endif

#ifndef NO_REVERB
	// Reverb
	m_SbReverbDepth.SetRange(1, 16);
	m_SbReverbDepth.SetPos(TrackerSettings::Instance().m_ReverbSettings.m_nReverbDepth);
	UINT nSel = 0;
	for (UINT iRvb=0; iRvb<NUM_REVERBTYPES; iRvb++)
	{
		CString pszName = mpt::ToCString(GetReverbPresetName(iRvb));
		if(!pszName.IsEmpty())
		{
			UINT n = m_CbnReverbPreset.AddString(pszName);
			m_CbnReverbPreset.SetItemData(n, iRvb);
			if (iRvb == TrackerSettings::Instance().m_ReverbSettings.m_nReverbType) nSel = n;
		}
	}
	m_CbnReverbPreset.SetCurSel(nSel);
	if (dwQuality & SNDDSP_REVERB) CheckDlgButton(IDC_CHECK6, BST_CHECKED);
#else
	GetDlgItem(IDC_CHECK6)->EnableWindow(FALSE);
	m_SbReverbDepth.EnableWindow(FALSE);
	m_CbnReverbPreset.EnableWindow(FALSE);
#endif

#ifndef NO_DSP
	// Surround
	{
		UINT n = TrackerSettings::Instance().m_SurroundSettings.m_nProLogicDepth;
		if (n < 1) n = 1;
		if (n > 16) n = 16;
		m_SbSurroundDepth.SetRange(1, 16);
		m_SbSurroundDepth.SetPos(n);
		m_SbSurroundDelay.SetRange(0, 8);
		m_SbSurroundDelay.SetPos((TrackerSettings::Instance().m_SurroundSettings.m_nProLogicDelay-5)/5);
	}
#else
	m_SbSurroundDepth.EnableWindow(FALSE);
	m_SbSurroundDelay.EnableWindow(FALSE);
#endif

	return TRUE;
}


BOOL COptionsPlayer::OnSetActive()
{
	CMainFrame::m_nLastOptionsPage = OPTIONS_PAGE_PLAYER;

	SetDlgItemText(IDC_EQ_WARNING,
		_T("Note: This EQ is applied to any and all of the modules ")
		_T("that you load in OpenMPT; its settings are stored globally, ")
		_T("rather than in each file. This means that you should avoid ")
		_T("using it as part of your production process, and instead only ")
		_T("use it to correct deficiencies in your audio hardware."));

	return CPropertyPage::OnSetActive();
}


void COptionsPlayer::OnHScroll(UINT nSBCode, UINT, CScrollBar *psb)
{
	if (nSBCode == SB_ENDSCROLL) return;
	if ((psb) && (psb->m_hWnd == m_SbReverbDepth.m_hWnd))
	{
#ifndef NO_REVERB
		UINT n = m_SbReverbDepth.GetPos();
		if ((n) && (n <= 16)) TrackerSettings::Instance().m_ReverbSettings.m_nReverbDepth = n;
		//if ((n) && (n <= 16)) CSoundFile::m_Reverb.m_Settings.m_nReverbDepth = n;
		CMainFrame::GetMainFrame()->SetupPlayer();
#endif
	} else
	{
		OnSettingsChanged();
	}
}


void COptionsPlayer::OnOK()
{
	DWORD dwQuality = 0;

	DWORD dwQualityMask = 0;

#ifndef NO_DSP
	dwQualityMask |= SNDDSP_MEGABASS;
	if (IsDlgButtonChecked(IDC_CHECK1)) dwQuality |= SNDDSP_MEGABASS;
#endif
#ifndef NO_AGC
	dwQualityMask |= SNDDSP_AGC;
	if (IsDlgButtonChecked(IDC_CHECK2)) dwQuality |= SNDDSP_AGC;
#endif
#ifndef NO_EQ
	dwQualityMask |= SNDDSP_EQ;
	if (IsDlgButtonChecked(IDC_CHECK3)) dwQuality |= SNDDSP_EQ;
#endif
#ifndef NO_DSP
	dwQualityMask |= SNDDSP_SURROUND;
	if (IsDlgButtonChecked(IDC_CHECK4)) dwQuality |= SNDDSP_SURROUND;
#endif
#ifndef NO_REVERB
	dwQualityMask |= SNDDSP_REVERB;
	if (IsDlgButtonChecked(IDC_CHECK6)) dwQuality |= SNDDSP_REVERB;
#endif
#ifndef NO_DSP
	dwQualityMask |= SNDDSP_BITCRUSH;
	if (IsDlgButtonChecked(IDC_CHECK5)) dwQuality |= SNDDSP_BITCRUSH;
#endif

#ifndef NO_DSP
	{
		TrackerSettings::Instance().m_BitCrushSettings.m_Bits = m_SbBitCrushBits.GetPos();
	}
#endif

#ifndef NO_DSP
	// Bass Expansion
	{
		UINT nXBassDepth = 8-m_SbXBassDepth.GetPos();
		if (nXBassDepth < 4) nXBassDepth = 4;
		if (nXBassDepth > 8) nXBassDepth = 8;
		UINT nXBassRange = (4-m_SbXBassRange.GetPos()) * 5 + 1;
		if (nXBassRange < 5) nXBassRange = 5;
		if (nXBassRange > 21) nXBassRange = 21;
		TrackerSettings::Instance().m_MegaBassSettings.m_nXBassDepth = nXBassDepth;
		TrackerSettings::Instance().m_MegaBassSettings.m_nXBassRange = nXBassRange;
	}
#endif
#ifndef NO_REVERB
	// Reverb
	{
		// Reverb depth is dynamically changed
		uint32 nReverbType = static_cast<uint32>(m_CbnReverbPreset.GetItemData(m_CbnReverbPreset.GetCurSel()));
		if (nReverbType < NUM_REVERBTYPES) TrackerSettings::Instance().m_ReverbSettings.m_nReverbType = nReverbType;
	}
#endif
#ifndef NO_DSP
	// Surround
	{
		UINT nProLogicDepth = m_SbSurroundDepth.GetPos();
		UINT nProLogicDelay = 5 + (m_SbSurroundDelay.GetPos() * 5);
		TrackerSettings::Instance().m_SurroundSettings.m_nProLogicDepth = nProLogicDepth;
		TrackerSettings::Instance().m_SurroundSettings.m_nProLogicDelay = nProLogicDelay;
	}
#endif

	TrackerSettings::Instance().MixerDSPMask = dwQuality;

	CMainFrame::GetMainFrame()->SetupPlayer();
	CPropertyPage::OnOK();
}


#ifndef NO_EQ

void COptionsPlayer::UpdateEQ(bool bReset)
{
	CriticalSection cs;
	if(CMainFrame::GetMainFrame()->GetSoundFilePlaying())
		CMainFrame::GetMainFrame()->GetSoundFilePlaying()->SetEQGains(m_EQPreset.Gains, m_EQPreset.Freqs, bReset);
}


void COptionsPlayer::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar *pScrollBar)
{
	CDialog::OnVScroll(nSBCode, nPos, pScrollBar);
	for (UINT i=0; i<MAX_EQ_BANDS; i++)
	{
		int n = 32 - m_Sliders[i].GetPos();
		if ((n >= 0) && (n <= 32)) m_EQPreset.Gains[i] = n;
	}
	UpdateEQ(FALSE);
}


void COptionsPlayer::LoadEQPreset(const EQPreset &preset)
{
	m_EQPreset = preset;
	UpdateEQ(TRUE);
	UpdateDialog();
}


void COptionsPlayer::OnSavePreset()
{
	CEQSavePresetDlg dlg(m_EQPreset, this);
	if (dlg.DoModal() == IDOK)
	{
		UpdateDialog();
	}
}


static CString f2s(UINT f)
{
	if (f < 1000)
	{
		return MPT_CFORMAT("{}Hz")(f);
	} else
	{
		UINT fHi = f / 1000u;
		UINT fLo = f % 1000u;
		if(fLo)
		{
			return MPT_CFORMAT("{}.{}kHz")(fHi, mpt::cfmt::dec0<1>(fLo/100));
		} else
		{
			return MPT_CFORMAT("{}kHz")(fHi);
		}
	}
}


void COptionsPlayer::UpdateDialog()
{
	for (UINT i=0; i<MAX_EQ_BANDS; i++)
	{
		int n = 32 - m_EQPreset.Gains[i];
		if (n < 0) n = 0;
		if (n > 32) n = 32;
		if (n != (m_Sliders[i].GetPos() & 0xFFFF)) m_Sliders[i].SetPos(n);
		SetDlgItemText(IDC_TEXT1 + i, f2s(m_EQPreset.Freqs[i]));
	}
	for(unsigned int i = 0; i < std::size(TrackerSettings::Instance().m_EqUserPresets); i++)
	{
		SetDlgItemText(IDC_BUTTON1 + i, mpt::ToCString(mpt::Charset::Locale, TrackerSettings::Instance().m_EqUserPresets[i].szName));
	}
}


void COptionsPlayer::OnSliderMenu(UINT nID)
{
	UINT n = nID - ID_EQSLIDER_BASE;
	if (n < MAX_EQ_BANDS)
	{
		HMENU hMenu = ::CreatePopupMenu();
		m_nSliderMenu = n;
		if (!hMenu) return;
		const UINT *pFreqs = gEqBandFreqs[m_nSliderMenu];
		for (UINT i = 0; i < EQ_MAX_FREQS; i++)
		{
			DWORD d = MF_STRING;
			if (m_EQPreset.Freqs[m_nSliderMenu] == pFreqs[i]) d |= MF_CHECKED;
			::AppendMenu(hMenu, d, ID_EQMENU_BASE+i, f2s(pFreqs[i]));
		}
		CPoint pt(m_Sliders[m_nSliderMenu].m_x, m_Sliders[m_nSliderMenu].m_y);
		m_Sliders[m_nSliderMenu].ClientToScreen(&pt);
		::TrackPopupMenu(hMenu, TPM_LEFTALIGN|TPM_RIGHTBUTTON, pt.x, pt.y, 0, m_hWnd, NULL);
		::DestroyMenu(hMenu);
	}
}


void COptionsPlayer::OnSliderFreq(UINT nID)
{
	UINT n = nID - ID_EQMENU_BASE;
	if ((m_nSliderMenu < MAX_EQ_BANDS) && (n < EQ_MAX_FREQS))
	{
		UINT f = gEqBandFreqs[m_nSliderMenu][n];
		if (f != m_EQPreset.Freqs[m_nSliderMenu])
		{
			m_EQPreset.Freqs[m_nSliderMenu] = f;
			UpdateEQ(TRUE);
			UpdateDialog();
		}
	}
}

#endif // !NO_EQ


/////////////////////////////////////////////////////////////
// CMidiSetupDlg

BEGIN_MESSAGE_MAP(CMidiSetupDlg, CPropertyPage)
	ON_CBN_SELCHANGE(IDC_COMBO1,			&CMidiSetupDlg::OnSettingsChanged)
	ON_CBN_SELCHANGE(IDC_COMBO2,			&CMidiSetupDlg::OnSettingsChanged)
	ON_CBN_SELCHANGE(IDC_COMBO3,			&CMidiSetupDlg::OnSettingsChanged)
	ON_COMMAND(IDC_BUTTON1,					&CMidiSetupDlg::OnRenameDevice)
	ON_COMMAND(IDC_CHECK1,					&CMidiSetupDlg::OnSettingsChanged)
	ON_COMMAND(IDC_CHECK2,					&CMidiSetupDlg::OnSettingsChanged)
	ON_COMMAND(IDC_CHECK3,					&CMidiSetupDlg::OnSettingsChanged)
	ON_COMMAND(IDC_CHECK4,					&CMidiSetupDlg::OnSettingsChanged)
	ON_COMMAND(IDC_CHECK5,					&CMidiSetupDlg::OnSettingsChanged)
	ON_COMMAND(IDC_MIDI_TO_PLUGIN,			&CMidiSetupDlg::OnSettingsChanged)
	ON_COMMAND(IDC_MIDI_MACRO_CONTROL,		&CMidiSetupDlg::OnSettingsChanged)
	ON_COMMAND(IDC_MIDIVOL_TO_NOTEVOL,		&CMidiSetupDlg::OnSettingsChanged)
	ON_COMMAND(IDC_MIDIPLAYCONTROL,			&CMidiSetupDlg::OnSettingsChanged)
	ON_COMMAND(IDC_MIDIPLAYPATTERNONMIDIIN,	&CMidiSetupDlg::OnSettingsChanged)
	ON_EN_CHANGE(IDC_EDIT1,					&CMidiSetupDlg::OnSettingsChanged)
	ON_EN_CHANGE(IDC_EDIT2,					&CMidiSetupDlg::OnSettingsChanged)
	ON_EN_CHANGE(IDC_EDIT3,					&CMidiSetupDlg::OnSettingsChanged)
	ON_EN_CHANGE(IDC_EDIT4,					&CMidiSetupDlg::OnSettingsChanged)
END_MESSAGE_MAP()


void CMidiSetupDlg::DoDataExchange(CDataExchange* pDX)
{
	CPropertyPage::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(COptionsSoundcard)
	DDX_Control(pDX, IDC_SPIN1,		m_SpinSpd);
	DDX_Control(pDX, IDC_SPIN2,		m_SpinPat);
	DDX_Control(pDX, IDC_SPIN3,		m_SpinAmp);
	DDX_Control(pDX, IDC_COMBO1,	m_InputDevice);
	DDX_Control(pDX, IDC_COMBO2,	m_ATBehaviour);
	DDX_Control(pDX, IDC_COMBO3,	m_Quantize);
	//}}AFX_DATA_MAP
}


BOOL CMidiSetupDlg::OnInitDialog()
{
	CPropertyPage::OnInitDialog();
	// Flags
	if (m_dwMidiSetup & MIDISETUP_RECORDVELOCITY) CheckDlgButton(IDC_CHECK1, BST_CHECKED);
	if (m_dwMidiSetup & MIDISETUP_RECORDNOTEOFF) CheckDlgButton(IDC_CHECK2, BST_CHECKED);
	if (m_dwMidiSetup & MIDISETUP_ENABLE_RECORD_DEFAULT) CheckDlgButton(IDC_CHECK3, BST_CHECKED);
	if (m_dwMidiSetup & MIDISETUP_TRANSPOSEKEYBOARD) CheckDlgButton(IDC_CHECK4, BST_CHECKED);
	if (m_dwMidiSetup & MIDISETUP_MIDITOPLUG) CheckDlgButton(IDC_MIDI_TO_PLUGIN, BST_CHECKED);
	if (m_dwMidiSetup & MIDISETUP_MIDIMACROCONTROL) CheckDlgButton(IDC_MIDI_MACRO_CONTROL, BST_CHECKED);
	if (m_dwMidiSetup & MIDISETUP_MIDIVOL_TO_NOTEVOL) CheckDlgButton(IDC_MIDIVOL_TO_NOTEVOL, BST_CHECKED);
	if (m_dwMidiSetup & MIDISETUP_RESPONDTOPLAYCONTROLMSGS) CheckDlgButton(IDC_MIDIPLAYCONTROL, BST_CHECKED);
	if (m_dwMidiSetup & MIDISETUP_PLAYPATTERNONMIDIIN) CheckDlgButton(IDC_MIDIPLAYPATTERNONMIDIIN, BST_CHECKED);
	if (m_dwMidiSetup & MIDISETUP_MIDIMACROPITCHBEND) CheckDlgButton(IDC_CHECK5, BST_CHECKED);

	// Midi In Device
	RefreshDeviceList(m_nMidiDevice);

	// Aftertouch behaviour
	m_ATBehaviour.ResetContent();
	static constexpr std::pair<const TCHAR *, RecordAftertouchOptions> aftertouchOptions[] =
	{
		{ _T("Do not record Aftertouch"), atDoNotRecord },
		{ _T("Record as Volume Commands"), atRecordAsVolume },
		{ _T("Record as MIDI Macros"), atRecordAsMacro },
	};

	for(const auto & [str, value] : aftertouchOptions)
	{
		int item = m_ATBehaviour.AddString(str);
		m_ATBehaviour.SetItemData(item, value);
		if(value == TrackerSettings::Instance().aftertouchBehaviour)
		{
			m_ATBehaviour.SetCurSel(item);
		}
	}

	// Note Velocity amp
	SetDlgItemInt(IDC_EDIT3, TrackerSettings::Instance().midiVelocityAmp);
	m_SpinAmp.SetRange(1, 10000);

	SetDlgItemText(IDC_EDIT4, mpt::ToCString(IgnoredCCsToString(TrackerSettings::Instance().midiIgnoreCCs)));

	// Midi Import settings
	SetDlgItemInt(IDC_EDIT1, TrackerSettings::Instance().midiImportTicks);
	SetDlgItemInt(IDC_EDIT2, TrackerSettings::Instance().midiImportPatternLen);

	// Note quantization
	m_Quantize.ResetContent();
	static constexpr std::pair<const TCHAR *, uint32> quantizeOptions[] =
	{
		{ _T("1/4th Notes"),  4 },  { _T("1/6th Notes"),  6 },
		{ _T("1/8th Notes"),  8 },  { _T("1/12th Notes"), 12 },
		{ _T("1/16th Notes"), 16 }, { _T("1/24th Notes"), 24 },
		{ _T("1/32nd Notes"), 32 }, { _T("1/48th Notes"), 48 },
		{ _T("1/64th Notes"), 64 }, { _T("1/96th Notes"), 96 },
	};

	for(const auto & [str, value]: quantizeOptions)
	{
		int item = m_Quantize.AddString(str);
		m_Quantize.SetItemData(item, value);
		if(value == TrackerSettings::Instance().midiImportQuantize)
		{
			m_Quantize.SetCurSel(item);
		}
	}
	m_SpinSpd.SetRange(2, 16);
	m_SpinPat.SetRange(1, MAX_PATTERN_ROWS);
	return TRUE;
}


void CMidiSetupDlg::RefreshDeviceList(UINT currentDevice)
{
	m_InputDevice.SetRedraw(FALSE);
	m_InputDevice.ResetContent();
	UINT ndevs = midiInGetNumDevs();
	for(UINT i = 0; i < ndevs; i++)
	{
		MIDIINCAPS mic;
		mic.szPname[0] = 0;
		if(midiInGetDevCaps(i, &mic, sizeof(mic)) == MMSYSERR_NOERROR)
		{
			int item = m_InputDevice.AddString(theApp.GetFriendlyMIDIPortName(mpt::ToCString(mpt::String::ReadWinBuf(mic.szPname)), true));
			m_InputDevice.SetItemData(item, i);
			if(i == currentDevice)
			{
				m_InputDevice.SetCurSel(item);
			}
		}
	}
	m_InputDevice.SetRedraw(TRUE);
	m_InputDevice.Invalidate(FALSE);
}


void CMidiSetupDlg::OnRenameDevice()
{
	int n = m_InputDevice.GetCurSel();
	if(n >= 0)
	{
		UINT device = static_cast<UINT>(m_InputDevice.GetItemData(n));
		MIDIINCAPS mic;
		mic.szPname[0] = 0;
		midiInGetDevCaps(device, &mic, sizeof(mic));
		CString name = mic.szPname;
		CString friendlyName = theApp.GetSettings().Read(U_("MIDI Input Ports"), mpt::ToUnicode(name), name);
		CInputDlg dlg(this, _T("New name for ") + name + _T(":"), friendlyName);
		if(dlg.DoModal() == IDOK)
		{
			if(dlg.resultAsString.IsEmpty() || dlg.resultAsString == name)
				theApp.GetSettings().Remove(U_("MIDI Input Ports"), mpt::ToUnicode(name));
			else
				theApp.GetSettings().Write(U_("MIDI Input Ports"), mpt::ToUnicode(name), dlg.resultAsString);
			RefreshDeviceList(device);
		}
	}
}


void CMidiSetupDlg::OnOK()
{
	CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
	m_dwMidiSetup = 0;
	m_nMidiDevice = MIDI_MAPPER;
	if (IsDlgButtonChecked(IDC_CHECK1)) m_dwMidiSetup |= MIDISETUP_RECORDVELOCITY;
	if (IsDlgButtonChecked(IDC_CHECK2)) m_dwMidiSetup |= MIDISETUP_RECORDNOTEOFF;
	if (IsDlgButtonChecked(IDC_CHECK3)) m_dwMidiSetup |= MIDISETUP_ENABLE_RECORD_DEFAULT;
	if (IsDlgButtonChecked(IDC_CHECK4)) m_dwMidiSetup |= MIDISETUP_TRANSPOSEKEYBOARD;
	if (IsDlgButtonChecked(IDC_MIDI_TO_PLUGIN)) m_dwMidiSetup |= MIDISETUP_MIDITOPLUG;
	if (IsDlgButtonChecked(IDC_MIDI_MACRO_CONTROL)) m_dwMidiSetup |= MIDISETUP_MIDIMACROCONTROL;
	if (IsDlgButtonChecked(IDC_MIDIVOL_TO_NOTEVOL)) m_dwMidiSetup |= MIDISETUP_MIDIVOL_TO_NOTEVOL;
	if (IsDlgButtonChecked(IDC_MIDIPLAYCONTROL)) m_dwMidiSetup |= MIDISETUP_RESPONDTOPLAYCONTROLMSGS;
	if (IsDlgButtonChecked(IDC_MIDIPLAYPATTERNONMIDIIN)) m_dwMidiSetup |= MIDISETUP_PLAYPATTERNONMIDIIN;
	if (IsDlgButtonChecked(IDC_CHECK5)) m_dwMidiSetup |= MIDISETUP_MIDIMACROPITCHBEND;

	int n = m_InputDevice.GetCurSel();
	if (n >= 0) m_nMidiDevice = static_cast<UINT>(m_InputDevice.GetItemData(n));

	TrackerSettings::Instance().aftertouchBehaviour = static_cast<RecordAftertouchOptions>(m_ATBehaviour.GetItemData(m_ATBehaviour.GetCurSel()));

	TrackerSettings::Instance().midiVelocityAmp = static_cast<uint16>(Clamp(GetDlgItemInt(IDC_EDIT3), 1u, 10000u));

	CString cc;
	GetDlgItemText(IDC_EDIT4, cc);
	TrackerSettings::Instance().midiIgnoreCCs = StringToIgnoredCCs(mpt::ToUnicode(cc));

	TrackerSettings::Instance().midiImportTicks = static_cast<uint8>(Clamp(GetDlgItemInt(IDC_EDIT1), uint8(2), uint8(16)));
	TrackerSettings::Instance().midiImportPatternLen = Clamp(GetDlgItemInt(IDC_EDIT2), ROWINDEX(1), MAX_PATTERN_ROWS);
	if(m_Quantize.GetCurSel() != -1)
	{
		TrackerSettings::Instance().midiImportQuantize = static_cast<uint32>(m_Quantize.GetItemData(m_Quantize.GetCurSel()));
	}

	if (pMainFrm) pMainFrm->SetupMidi(m_dwMidiSetup, m_nMidiDevice);
	CPropertyPage::OnOK();
}


BOOL CMidiSetupDlg::OnSetActive()
{
	CMainFrame::m_nLastOptionsPage = OPTIONS_PAGE_MIDI;
	return CPropertyPage::OnSetActive();
}


// Wine


BEGIN_MESSAGE_MAP(COptionsWine, CPropertyPage)
	ON_COMMAND(IDC_CHECK_WINE_ENABLE, &COptionsWine::OnSettingsChanged)
	ON_CBN_SELCHANGE(IDC_COMBO_WINE_PULSEAUDIO, &COptionsWine::OnSettingsChanged)
	ON_CBN_SELCHANGE(IDC_COMBO_WINE_PORTAUDIO, &COptionsWine::OnSettingsChanged)
	ON_CBN_SELCHANGE(IDC_COMBO_WINE_RTAUDIO, &COptionsWine::OnSettingsChanged)
END_MESSAGE_MAP()


COptionsWine::COptionsWine()
	: CPropertyPage(IDD_OPTIONS_WINE)
{
	return;
}


void COptionsWine::DoDataExchange(CDataExchange* pDX)
{
	CPropertyPage::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(COptionsWine)
	DDX_Control(pDX, IDC_COMBO_WINE_PULSEAUDIO, m_CbnPulseAudio);
	DDX_Control(pDX, IDC_COMBO_WINE_PORTAUDIO, m_CbnPortAudio);
	DDX_Control(pDX, IDC_COMBO_WINE_RTAUDIO, m_CbnRtAudio);
	//}}AFX_DATA_MAP
}


BOOL COptionsWine::OnInitDialog()
{
	CPropertyPage::OnInitDialog();
	GetDlgItem(IDC_CHECK_WINE_ENABLE)->EnableWindow(mpt::OS::Windows::IsWine() ? TRUE : FALSE);
	CheckDlgButton(IDC_CHECK_WINE_ENABLE, TrackerSettings::Instance().WineSupportEnabled ? BST_CHECKED : BST_UNCHECKED);
	int index;
	index = m_CbnPulseAudio.AddString(_T("Auto"    )); m_CbnPulseAudio.SetItemData(index, 1);
	index = m_CbnPulseAudio.AddString(_T("Enabled" )); m_CbnPulseAudio.SetItemData(index, 2);
	index = m_CbnPulseAudio.AddString(_T("Disabled")); m_CbnPulseAudio.SetItemData(index, 0);
	m_CbnPulseAudio.SetCurSel(0);
	for(index = 0; index < 3; ++index)
	{
		if(m_CbnPulseAudio.GetItemData(index) == static_cast<uint32>(TrackerSettings::Instance().WineSupportEnablePulseAudio))
		{
			m_CbnPulseAudio.SetCurSel(index);
		}
	}
	index = m_CbnPortAudio.AddString(_T("Auto"    )); m_CbnPortAudio.SetItemData(index, 1);
	index = m_CbnPortAudio.AddString(_T("Enabled" )); m_CbnPortAudio.SetItemData(index, 2);
	index = m_CbnPortAudio.AddString(_T("Disabled")); m_CbnPortAudio.SetItemData(index, 0);
	for(index = 0; index < 3; ++index)
	{
		if(m_CbnPortAudio.GetItemData(index) == static_cast<uint32>(TrackerSettings::Instance().WineSupportEnablePortAudio))
		{
			m_CbnPortAudio.SetCurSel(index);
		}
	}
	index = m_CbnRtAudio.AddString(_T("Auto"    )); m_CbnRtAudio.SetItemData(index, 1);
	index = m_CbnRtAudio.AddString(_T("Enabled" )); m_CbnRtAudio.SetItemData(index, 2);
	index = m_CbnRtAudio.AddString(_T("Disabled")); m_CbnRtAudio.SetItemData(index, 0);
	for(index = 0; index < 3; ++index)
	{
		if(m_CbnRtAudio.GetItemData(index) == static_cast<uint32>(TrackerSettings::Instance().WineSupportEnableRtAudio))
		{
			m_CbnRtAudio.SetCurSel(index);
		}
	}
	return TRUE;
}


void COptionsWine::OnSettingsChanged()
{
	SetModified(TRUE);
}


void COptionsWine::OnOK()
{
	TrackerSettings::Instance().WineSupportEnabled = IsDlgButtonChecked(IDC_CHECK_WINE_ENABLE) ? true : false;
	TrackerSettings::Instance().WineSupportEnablePulseAudio = static_cast<int32>(m_CbnPulseAudio.GetItemData(m_CbnPulseAudio.GetCurSel()));
	TrackerSettings::Instance().WineSupportEnablePortAudio = static_cast<int32>(m_CbnPortAudio.GetItemData(m_CbnPortAudio.GetCurSel()));
	TrackerSettings::Instance().WineSupportEnableRtAudio = static_cast<int32>(m_CbnRtAudio.GetItemData(m_CbnRtAudio.GetCurSel()));
	CPropertyPage::OnOK();
}


BOOL COptionsWine::OnSetActive()
{
	CMainFrame::m_nLastOptionsPage = OPTIONS_PAGE_WINE;
	return CPropertyPage::OnSetActive();
}


OPENMPT_NAMESPACE_END