random-mirrors
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/external_dependencies/openmpt-trunk/mptrack/Mpdlgs.cpp

1992 lines
62 KiB
C++
Raw Permalink Blame History

/*
* 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
Reference in New Issue View Git Blame Copy Permalink