[OMPT-svn-commit] SF.net SVN: modplug:[1172] trunk/OpenMPT

[<sag...@us...>]

Revision: 1172
          http://modplug.svn.sourceforge.net/modplug/?rev=1172&view=rev
Author:   saga-games
Date:     2012-02-06 23:55:02 +0000 (Mon, 06 Feb 2012)
Log Message:
-----------
[Ref] Lots of refactoring regarding to MIDI macros again. Now all MIDI macro operations are in the same class as the MIDI macros themselves, yay.
[Ref] Moved around some plugin interface stuff to escape forward referencing hell.

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/AbstractVstEditor.cpp
    trunk/OpenMPT/mptrack/CleanupSong.cpp
    trunk/OpenMPT/mptrack/Ctrl_pat.cpp
    trunk/OpenMPT/mptrack/Ctrl_smp.cpp
    trunk/OpenMPT/mptrack/MIDIMacroDialog.cpp
    trunk/OpenMPT/mptrack/MIDIMacroDialog.h
    trunk/OpenMPT/mptrack/Moddoc.cpp
    trunk/OpenMPT/mptrack/Mptrack.cpp
    trunk/OpenMPT/mptrack/Mptrack.h
    trunk/OpenMPT/mptrack/TrackerSettings.cpp
    trunk/OpenMPT/mptrack/View_pat.cpp
    trunk/OpenMPT/mptrack/Vstplug.h
    trunk/OpenMPT/mptrack/mptrack.vcproj
    trunk/OpenMPT/mptrack/mptrack_08.vcproj
    trunk/OpenMPT/mptrack/mptrack_10.vcxproj
    trunk/OpenMPT/mptrack/mptrack_10.vcxproj.filters
    trunk/OpenMPT/mptrack/test/test.cpp
    trunk/OpenMPT/soundlib/Load_it.cpp
    trunk/OpenMPT/soundlib/Load_itp.cpp
    trunk/OpenMPT/soundlib/Load_xm.cpp
    trunk/OpenMPT/soundlib/MIDIMacros.cpp
    trunk/OpenMPT/soundlib/MIDIMacros.h
    trunk/OpenMPT/soundlib/Sndfile.cpp
    trunk/OpenMPT/soundlib/Sndfile.h

Added Paths:
-----------
    trunk/OpenMPT/soundlib/PlugInterface.h

Modified: trunk/OpenMPT/mptrack/AbstractVstEditor.cpp
===================================================================
--- trunk/OpenMPT/mptrack/AbstractVstEditor.cpp	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/mptrack/AbstractVstEditor.cpp	2012-02-06 23:55:02 UTC (rev 1172)
@@ -566,7 +566,7 @@
 void CAbstractVstEditor::UpdateMacroMenu()
 //----------------------------------------
 {
-	CString label, macroName, macroText;
+	CString label, macroName;
 	bool greyed;
 	int action;
 
@@ -590,13 +590,13 @@
 
 	for (int nMacro = 0; nMacro < NUM_MACROS; nMacro++)
 	{
-		MIDIMacroTools macroTools(*pModDoc->GetSoundFile());
-
 		action = NULL;
 		greyed = true;
-		macroText = pModDoc->GetSoundFile()->m_MidiCfg.szMidiSFXExt[nMacro];
- 		const enmParameteredMacroType macroType = macroTools.GetMacroType(macroText);
 
+		const MIDIMacroConfig &midiCfg = pModDoc->GetSoundFile()->m_MidiCfg;
+
+ 		const parameteredMacroType macroType = midiCfg.GetParameteredMacroType(nMacro);
+
 		if(macroType == sfx_unused)
 		{
 			macroName = "Unused. Learn Param..."; 
@@ -604,7 +604,7 @@
 			greyed = false; 
 		} else
 		{
-			macroName = macroTools.GetMacroName(macroText, m_pVstPlugin->GetSlot());
+			macroName = midiCfg.GetParameteredMacroName(nMacro, m_pVstPlugin->GetSlot(), *pModDoc->GetSoundFile());
 			if(macroType != sfx_plug || macroName.Left(3) != "N/A")
 			{
 				greyed = false;

Modified: trunk/OpenMPT/mptrack/CleanupSong.cpp
===================================================================
--- trunk/OpenMPT/mptrack/CleanupSong.cpp	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/mptrack/CleanupSong.cpp	2012-02-06 23:55:02 UTC (rev 1172)
@@ -900,7 +900,7 @@
 	pSndFile->m_nMixLevels = mixLevels_compatible;
 	pSndFile->m_nTempoMode = tempo_mode_classic;
 	pSndFile->m_dwSongFlags = SONG_LINEARSLIDES;
-	CSoundFile::ResetMidiCfg(pSndFile->m_MidiCfg);
+	pSndFile->m_MidiCfg.Reset();
 	
 	// Global vars
 	pSndFile->m_nDefaultTempo = 125;

Modified: trunk/OpenMPT/mptrack/Ctrl_pat.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_pat.cpp	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/mptrack/Ctrl_pat.cpp	2012-02-06 23:55:02 UTC (rev 1172)
@@ -1142,8 +1142,7 @@
 				m_pSndFile->m_dwSongFlags &= ~SONG_EMBEDMIDICFG;
 
 				// If this macro is not the default IT macro, display a warning.
-				MIDIMacroTools macroTools(*m_pSndFile);
-				if(!macroTools.IsMacroDefaultSetupUsed())
+				if(!m_pSndFile->m_MidiCfg.IsMacroDefaultSetupUsed())
 				{
 					if(Reporting::Confirm(_T("You have chosen not to embed MIDI macros. However, the current macro configuration differs from the default macro configuration that is assumed when loading a file that has no macros embedded. This can result in data loss and broken playback.\nWould you like to embed MIDI macros now?")) == cnfYes)
 					{

Modified: trunk/OpenMPT/mptrack/Ctrl_smp.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_smp.cpp	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/mptrack/Ctrl_smp.cpp	2012-02-06 23:55:02 UTC (rev 1172)
@@ -379,7 +379,7 @@
 		{
 			if (pSndFile->GetNumInstruments())
 			{
-				UINT k = m_pParent->GetInstrumentChange();
+				INSTRUMENTINDEX k = m_pParent->GetInstrumentChange();
 				if (!pModDoc->IsChildSample(k, lParam))
 				{
 					UINT nins = pModDoc->FindSampleParent(lParam);

Modified: trunk/OpenMPT/mptrack/MIDIMacroDialog.cpp
===================================================================
--- trunk/OpenMPT/mptrack/MIDIMacroDialog.cpp	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/mptrack/MIDIMacroDialog.cpp	2012-02-06 23:55:02 UTC (rev 1172)
@@ -73,7 +73,7 @@
 	m_CbnSFx.SetCurSel(0);
 	for(int i = 0; i < sfx_max; i++)
 	{
-		m_CbnSFxPreset.SetItemData(m_CbnSFxPreset.AddString(macroTools.GetMacroName(static_cast<enmParameteredMacroType>(i))), i);
+		m_CbnSFxPreset.SetItemData(m_CbnSFxPreset.AddString(m_MidiCfg.GetParameteredMacroName(static_cast<parameteredMacroType>(i))), i);
 	}
 	OnSFxChanged();
 
@@ -95,9 +95,9 @@
 	m_CbnZxx.SetCurSel(0);
 	for(int i = 0; i < zxx_max; i++)
 	{
-		m_CbnZxxPreset.SetItemData(m_CbnZxxPreset.AddString(macroTools.GetZxxName(static_cast<enmFixedMacroType>(i))), i);
+		m_CbnZxxPreset.SetItemData(m_CbnZxxPreset.AddString(m_MidiCfg.GetFixedMacroName(static_cast<fixedMacroType>(i))), i);
 	}
-	m_CbnZxxPreset.SetCurSel(macroTools.GetZxxType(m_MidiCfg.szMidiZXXExt));
+	m_CbnZxxPreset.SetCurSel(m_MidiCfg.GetFixedMacroType());
 
 	UpdateDialog();
 
@@ -171,24 +171,23 @@
 		m_EditMacro[m].SetWindowText(s);
 
 		// Macro value:
-		CString macroText = m_MidiCfg.szMidiSFXExt[m];
-		m_EditMacroValue[m].SetWindowText(macroText);
+		m_EditMacroValue[m].SetWindowText(m_MidiCfg.szMidiSFXExt[m]);
 		m_EditMacroValue[m].SetBackColor(m == selectedMacro ? RGB(200, 200, 225) : RGB(245, 245, 245));
 
 		// Macro Type:
-		const enmParameteredMacroType macroType = macroTools.GetMacroType(macroText);
+		const parameteredMacroType macroType = m_MidiCfg.GetParameteredMacroType(m);
 		switch (macroType)
 		{
 		case sfx_cc:
-			s.Format("MIDI CC %d", macroTools.MacroToMidiCC(macroText)); 
+			s.Format("MIDI CC %d", m_MidiCfg.MacroToMidiCC(m));
 			break;
 
 		case sfx_plug: 
-			s.Format("Control Plugin Param %d", macroTools.MacroToPlugParam(macroText)); 
+			s.Format("Control Plugin Param %d", m_MidiCfg.MacroToPlugParam(m));
 			break;
 
 		default:
-			s = macroTools.GetMacroName(macroType);
+			s = m_MidiCfg.GetParameteredMacroName(macroType);
 			break;
 		}
 		m_EditMacroType[m].SetWindowText(s);
@@ -276,9 +275,7 @@
 	UINT sfx = m_CbnSFx.GetCurSel();
 	if (sfx < 16)
 	{
-		CString macroText;
-		memcpy(macroText.GetBuffer(MACRO_LENGTH), m_MidiCfg.szMidiSFXExt[sfx], MACRO_LENGTH);
-		int preset = macroTools.GetMacroType(macroText);
+		int preset = m_MidiCfg.GetParameteredMacroType(sfx);
 		m_CbnSFxPreset.SetCurSel(preset);
 	}
 	UpdateDialog();
@@ -289,13 +286,13 @@
 //----------------------------------------
 {
 	UINT sfx = m_CbnSFx.GetCurSel();
-	enmParameteredMacroType sfx_preset = static_cast<enmParameteredMacroType>(m_CbnSFxPreset.GetItemData(m_CbnSFxPreset.GetCurSel()));
+	parameteredMacroType sfx_preset = static_cast<parameteredMacroType>(m_CbnSFxPreset.GetItemData(m_CbnSFxPreset.GetCurSel()));
 
 	if (sfx < 16)
 	{
 		if(sfx_preset != sfx_custom)
 		{
-			strcpy(m_MidiCfg.szMidiSFXExt[sfx], macroTools.CreateParameteredMacroFromType(sfx_preset));
+			m_MidiCfg.CreateParameteredMacro(sfx, sfx_preset);
 		}
 		UpdateDialog();
 	}
@@ -305,11 +302,11 @@
 void CMidiMacroSetup::OnZxxPresetChanged()
 //----------------------------------------
 {
-	enmFixedMacroType zxx_preset = static_cast<enmFixedMacroType>(m_CbnZxxPreset.GetItemData(m_CbnZxxPreset.GetCurSel()));
+	fixedMacroType zxx_preset = static_cast<fixedMacroType>(m_CbnZxxPreset.GetItemData(m_CbnZxxPreset.GetCurSel()));
 
 	if (zxx_preset != zxx_custom)
 	{
-		macroTools.CreateZxxFromType(m_MidiCfg.szMidiZXXExt, zxx_preset);
+		m_MidiCfg.CreateFixedMacro(zxx_preset);
 		UpdateDialog();
 	}
 }
@@ -329,7 +326,7 @@
 			StringFixer::SetNullTerminator(s);
 			memcpy(m_MidiCfg.szMidiSFXExt[sfx], s, MACRO_LENGTH);
 
-			int sfx_preset = macroTools.GetMacroType(m_MidiCfg.szMidiSFXExt[sfx]);
+			int sfx_preset = m_MidiCfg.GetParameteredMacroType(sfx);
 			m_CbnSFxPreset.SetCurSel(sfx_preset);
 			ToggleBoxes(sfx_preset, sfx);
 			UpdateMacroList(sfx);
@@ -367,7 +364,7 @@
 {
 	CString message, plugName, line;
 	int sfx = id - ID_PLUGSELECT;
-	int param = macroTools.MacroToPlugParam(m_MidiCfg.szMidiSFXExt[sfx]);
+	int param = m_MidiCfg.MacroToPlugParam(sfx);
 	CVstPlugin *pVstPlugin; 
 	message.Format("These are the parameters that can be controlled by macro SF%X:\n\n", sfx);
 
@@ -407,7 +404,7 @@
 		AddPluginParameternamesToCombobox(m_CbnMacroParam, *pVstPlugin);
 		m_CbnMacroParam.SetRedraw(TRUE);
 
-		int param = macroTools.MacroToPlugParam(m_MidiCfg.szMidiSFXExt[m_CbnSFx.GetCurSel()]);
+		int param = m_MidiCfg.MacroToPlugParam(m_CbnSFx.GetCurSel());
 		m_CbnMacroParam.SetCurSel(param);
 	}
 	//OnPlugParamChanged();
@@ -416,17 +413,12 @@
 void CMidiMacroSetup::OnPlugParamChanged()
 //----------------------------------------
 {
-	CString macroText;
 	UINT param = m_CbnMacroParam.GetItemData(m_CbnMacroParam.GetCurSel());
 
-	if(param < 128)
+	if(param < 384)
 	{
-		macroText.Format("F0F0%02Xz",param + 128);
-		m_EditSFx.SetWindowText(macroText);
-	} else if(param < 384)
-	{
-		macroText.Format("F0F1%02Xz",param - 128);
-		m_EditSFx.SetWindowText(macroText);
+		const std::string macroText = m_MidiCfg.CreateParameteredMacro(sfx_plug, param);
+		m_EditSFx.SetWindowText(macroText.c_str());
 	} else
 	{
 		Reporting::Notification("Only parameters 0 to 383 can be controlled using MIDI Macros. Use Parameter Control Events to automate higher parameters.");
@@ -436,10 +428,9 @@
 void CMidiMacroSetup::OnCCChanged()
 //---------------------------------
 {
-	CString macroText;
 	UINT cc = m_CbnMacroCC.GetItemData(m_CbnMacroCC.GetCurSel());
-	macroText.Format("Bc%02Xz", cc & 0xFF);
-	m_EditSFx.SetWindowText(macroText);
+	const std::string macroText = m_MidiCfg.CreateParameteredMacro(sfx_cc, cc);
+	m_EditSFx.SetWindowText(macroText.c_str());
 }
 
 void CMidiMacroSetup::ToggleBoxes(UINT sfx_preset, UINT sfx)
@@ -454,7 +445,7 @@
 		m_CbnMacroPlug.EnableWindow(TRUE);
 		m_CbnMacroParam.EnableWindow(TRUE);
 		SetDlgItemText(IDC_GENMACROLABEL, "Plug/Param");
-		m_CbnMacroParam.SetCurSel(macroTools.MacroToPlugParam(m_MidiCfg.szMidiSFXExt[sfx]));
+		m_CbnMacroParam.SetCurSel(m_MidiCfg.MacroToPlugParam(sfx));
 	} else
 	{
 		m_CbnMacroPlug.EnableWindow(FALSE);
@@ -468,7 +459,7 @@
 		m_CbnMacroPlug.ShowWindow(FALSE);
 		m_CbnMacroParam.ShowWindow(FALSE);
 		SetDlgItemText(IDC_GENMACROLABEL, "MIDI CC");
-		m_CbnMacroCC.SetCurSel(macroTools.MacroToMidiCC(m_MidiCfg.szMidiSFXExt[sfx]));
+		m_CbnMacroCC.SetCurSel(m_MidiCfg.MacroToMidiCC(sfx));
 	} else
 	{
 		m_CbnMacroCC.EnableWindow(FALSE);

Modified: trunk/OpenMPT/mptrack/MIDIMacroDialog.h
===================================================================
--- trunk/OpenMPT/mptrack/MIDIMacroDialog.h	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/mptrack/MIDIMacroDialog.h	2012-02-06 23:55:02 UTC (rev 1172)
@@ -19,13 +19,13 @@
 //===================================
 {
 public:
-	CMidiMacroSetup(CSoundFile &sndFile, CWnd *parent = NULL) : CDialog(IDD_MIDIMACRO, parent), m_SndFile(sndFile), macroTools(sndFile), m_MidiCfg(sndFile.m_MidiCfg)
+	CMidiMacroSetup(CSoundFile &sndFile, CWnd *parent = NULL) : CDialog(IDD_MIDIMACRO, parent), m_SndFile(sndFile), m_MidiCfg(sndFile.m_MidiCfg)
 	{
 		m_bEmbed = (m_SndFile.m_dwSongFlags & SONG_EMBEDMIDICFG) != 0;
 	}
 
 	bool m_bEmbed;
-	MODMIDICFG m_MidiCfg;
+	MIDIMacroConfig m_MidiCfg;
 
 
 protected:
@@ -35,7 +35,6 @@
 	CButton m_EditMacro[NUM_MACROS], m_BtnMacroShowAll[NUM_MACROS];
 
 	CSoundFile &m_SndFile;
-	MIDIMacroTools macroTools;
 
 	bool ValidateMacroString(CEdit &wnd, char *lastMacro, bool isParametric);
 

Modified: trunk/OpenMPT/mptrack/Moddoc.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Moddoc.cpp	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/mptrack/Moddoc.cpp	2012-02-06 23:55:02 UTC (rev 1172)
@@ -15,7 +15,6 @@
 #include "version.h"
 #include "modsmp_ctrl.h"
 #include "CleanupSong.h"
-#include "MIDIMacros.h"
 #include "../common/StringFixer.h"
 #include <shlwapi.h>
 
@@ -179,8 +178,7 @@
 	{
 		m_SndFile.m_dwSongFlags |= SONG_LINEARSLIDES;
 		
-		MIDIMacroTools macroTools(m_SndFile);
-		if(!macroTools.IsMacroDefaultSetupUsed())
+		if(!m_SndFile.m_MidiCfg.IsMacroDefaultSetupUsed())
 		{
 			m_SndFile.m_dwSongFlags |= SONG_EMBEDMIDICFG;
 		}
@@ -2307,7 +2305,7 @@
 
 
 bool CModDoc::GetEffectName(LPSTR pszDescription, MODCOMMAND::COMMAND command, UINT param, bool bXX, CHANNELINDEX nChn) //rewbs.xinfo: added chan arg
-//------------------------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------------------------------------
 {
 	bool bSupported;
 	UINT fxndx = MAX_FXINFO;
@@ -2342,22 +2340,24 @@
 		if (nChn < m_SndFile.m_nChannels)
 		{
 			CString chanSpec = "";
-			CString macroText= "_no macro_";
+			size_t macroIndex = size_t(-1);
+
 			switch (command)
 			{
 			case CMD_MODCMDEX:
 			case CMD_S3MCMDEX:
 				if ((param & 0xF0) == 0xF0 && !(m_SndFile.GetType() & MOD_TYPE_MOD))	//Set Macro
 				{
-					macroText = m_SndFile.m_MidiCfg.szMidiSFXExt[(param & 0x0F)];
+					macroIndex = (param & 0x0F);
 					chanSpec.Format(" to %d: ", param & 0x0F);
 				}
 				break;
+
 			case CMD_MIDI:
 			case CMD_SMOOTHMIDI:
 				if (param < 0x80 && nChn != CHANNELINDEX_INVALID)
 				{
-					macroText = m_SndFile.m_MidiCfg.szMidiSFXExt[m_SndFile.Chn[nChn].nActiveMacro];
+					macroIndex = m_SndFile.Chn[nChn].nActiveMacro;
 					chanSpec.Format(": currently %d: ", m_SndFile.Chn[nChn].nActiveMacro);
 				}
 				else
@@ -2367,11 +2367,10 @@
 				break;
 			}
 			
-			if (macroText != "_no macro_")
+			if(macroIndex != size_t(-1))
 			{
-				MIDIMacroTools macroTools(m_SndFile);
 				const PLUGINDEX plugin = m_SndFile.GetBestPlugin(nChn, PrioritiseChannel, EvenIfMuted) - 1;
-				chanSpec.Append(macroTools.GetMacroName(macroText, plugin));
+				chanSpec.Append(m_SndFile.m_MidiCfg.GetParameteredMacroName(macroIndex, plugin, *(this->GetSoundFile())));
 			}
 			if (chanSpec != "")
 			{
@@ -3574,10 +3573,9 @@
 	//if macro already exists for this param, alert user and return
 	for (int checkMacro = 0; checkMacro < NUM_MACROS; checkMacro++)
 	{
-		CString macroText = GetSoundFile()->m_MidiCfg.szMidiSFXExt[checkMacro];
-		int macroType = MIDIMacroTools::GetMacroType(macroText);
+		int macroType = GetSoundFile()->m_MidiCfg.GetParameteredMacroType(checkMacro);
 		
-		if (macroType==sfx_plug && MIDIMacroTools::MacroToPlugParam(macroText) == paramToUse)
+		if (macroType == sfx_plug && GetSoundFile()->m_MidiCfg.MacroToPlugParam(checkMacro) == paramToUse)
 		{
 			CString message;
 			message.Format("Parameter %02d can already be controlled with macro %X.", paramToUse, checkMacro);
@@ -3752,7 +3750,7 @@
 	}
 
 	// Macros
-	m_SndFile.SanitizeMacros();
+	m_SndFile.m_MidiCfg.Sanitize();
 
 	// Pattern names
 	// Those are CStrings and don't need to be fixed.

Modified: trunk/OpenMPT/mptrack/Mptrack.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Mptrack.cpp	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/mptrack/Mptrack.cpp	2012-02-06 23:55:02 UTC (rev 1172)
@@ -591,9 +591,7 @@
 	m_bDebugMode = FALSE;
 	m_hAlternateResourceHandle = NULL;
 	m_szConfigFileName[0] = 0;
-	for (UINT i=0; i<MAX_DLS_BANKS; i++) gpDLSBanks[i] = NULL;
-	// Reset default macro config
-	CSoundFile::ResetMidiCfg(m_MidiCfg);
+	for (size_t i = 0; i < MAX_DLS_BANKS; i++) gpDLSBanks[i] = NULL;
 }
 
 /////////////////////////////////////////////////////////////////////////////

Modified: trunk/OpenMPT/mptrack/Mptrack.h
===================================================================
--- trunk/OpenMPT/mptrack/Mptrack.h	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/mptrack/Mptrack.h	2012-02-06 23:55:02 UTC (rev 1172)
@@ -131,7 +131,7 @@
 	DWORD m_dwTimeStarted, m_dwLastPluginIdleCall;
 	HANDLE m_hAlternateResourceHandle;
 	// Default macro configuration
-	MODMIDICFG m_MidiCfg;
+	MIDIMacroConfig m_MidiCfg;
 	static TCHAR m_szExePath[_MAX_PATH];
 	TCHAR m_szConfigDirectory[_MAX_PATH];
 	TCHAR m_szConfigFileName[_MAX_PATH];
@@ -171,8 +171,8 @@
 public:
 	CDocTemplate *GetModDocTemplate() const { return m_pModTemplate; }
 	CVstPluginManager *GetPluginManager() const { return m_pPluginManager; }
-	void GetDefaultMidiMacro(MODMIDICFG *pcfg) const { *pcfg = m_MidiCfg; }
-	void SetDefaultMidiMacro(const MODMIDICFG *pcfg) { m_MidiCfg = *pcfg; }
+	void GetDefaultMidiMacro(MIDIMacroConfig *pcfg) const { *pcfg = m_MidiCfg; }
+	void SetDefaultMidiMacro(const MIDIMacroConfig *pcfg) { m_MidiCfg = *pcfg; }
 	void LoadChords(PMPTCHORD pChords);
 	void SaveChords(PMPTCHORD pChords);
 	BOOL CanEncodeLayer3() const { return acmConvert.IsLayer3Present(); }

Modified: trunk/OpenMPT/mptrack/TrackerSettings.cpp
===================================================================
--- trunk/OpenMPT/mptrack/TrackerSettings.cpp	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/mptrack/TrackerSettings.cpp	2012-02-06 23:55:02 UTC (rev 1172)
@@ -194,7 +194,7 @@
 	theApp.LoadChords(Chords);
 
 	// Load default macro configuration
-	MODMIDICFG macros;
+	MIDIMacroConfig macros;
 	theApp.GetDefaultMidiMacro(&macros);
 	for(int isfx = 0; isfx < 16; isfx++)
 	{
@@ -785,7 +785,7 @@
 	theApp.SaveChords(Chords);
 
 	// Save default macro configuration
-	MODMIDICFG macros;
+	MIDIMacroConfig macros;
 	theApp.GetDefaultMidiMacro(&macros);
 	for(int isfx = 0; isfx < 16; isfx++)
 	{

Modified: trunk/OpenMPT/mptrack/View_pat.cpp
===================================================================
--- trunk/OpenMPT/mptrack/View_pat.cpp	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/mptrack/View_pat.cpp	2012-02-06 23:55:02 UTC (rev 1172)
@@ -3216,8 +3216,6 @@
 		return 0;
 	}
 
-	MIDIMacroTools macroTools(*pSndFile);
-
 	//Work out where to put the new data
 	const UINT nChn = GetChanFromCursor(m_dwCursor);
 	const bool bUsePlaybackPosition = IsLiveRecord(*pModDoc, *pSndFile);
@@ -3253,16 +3251,17 @@
 		//Figure out which plug param (if any) is controllable using the active macro on this channel.
 		long activePlugParam  = -1;
 		BYTE activeMacro      = pSndFile->Chn[nChn].nActiveMacro;
-		CString activeMacroString = pSndFile->m_MidiCfg.szMidiSFXExt[activeMacro];
-		if (macroTools.GetMacroType(activeMacroString) == sfx_plug)
+
+		if (pSndFile->m_MidiCfg.GetParameteredMacroType(activeMacro) == sfx_plug)
 		{
-			activePlugParam = macroTools.MacroToPlugParam(activeMacroString);
+			activePlugParam = pSndFile->m_MidiCfg.MacroToPlugParam(activeMacro);
 		}
+
 		//If the wrong macro is active, see if we can find the right one.
 		//If we can, activate it for this chan by writing appropriate SFx command it.
 		if (activePlugParam != paramIndex)
 		{ 
-			int foundMacro = macroTools.FindMacroForParam(paramIndex);
+			int foundMacro = pSndFile->m_MidiCfg.FindMacroForParam(paramIndex);
 			if (foundMacro >= 0)
 			{
 				pSndFile->Chn[nChn].nActiveMacro = foundMacro;
@@ -3271,7 +3270,7 @@
 					pModDoc->GetPatternUndo().PrepareUndo(nPattern, nChn, nRow, 1, 1);
 
 					pRow->command = (pSndFile->m_nType & (MOD_TYPE_IT | MOD_TYPE_MPT)) ? CMD_S3MCMDEX : CMD_MODCMDEX;;
-					pRow->param = 0xF0 + (foundMacro&0x0F);
+					pRow->param = 0xF0 + (foundMacro & 0x0F);
 					InvalidateRow(nRow);
 				}
 

Modified: trunk/OpenMPT/mptrack/Vstplug.h
===================================================================
--- trunk/OpenMPT/mptrack/Vstplug.h	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/mptrack/Vstplug.h	2012-02-06 23:55:02 UTC (rev 1172)
@@ -8,6 +8,7 @@
 	#include <vstfxstore.h>
 #endif
 
+#include "../soundlib/Snd_defs.h"
 #include "../soundlib/PluginMixBuffer.h"
 
 #define kBuzzMagic	'Buzz'

Modified: trunk/OpenMPT/mptrack/mptrack.vcproj
===================================================================
--- trunk/OpenMPT/mptrack/mptrack.vcproj	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/mptrack/mptrack.vcproj	2012-02-06 23:55:02 UTC (rev 1172)
@@ -852,6 +852,9 @@
 				RelativePath=".\soundlib\PluginMixBuffer.h">
 			</File>
 			<File
+				RelativePath=".\soundlib\PlugInterface.h">
+			</File>
+			<File
 				RelativePath="..\common\Reporting.h">
 			</File>
 			<File

Modified: trunk/OpenMPT/mptrack/mptrack_08.vcproj
===================================================================
--- trunk/OpenMPT/mptrack/mptrack_08.vcproj	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/mptrack/mptrack_08.vcproj	2012-02-06 23:55:02 UTC (rev 1172)
@@ -1131,6 +1131,10 @@
 				>
 			</File>
 			<File
+				RelativePath=".\soundlib\PlugInterface.h"
+				>
+			</File>
+			<File
 				RelativePath="..\common\Reporting.h"
 				>
 			</File>

Modified: trunk/OpenMPT/mptrack/mptrack_10.vcxproj
===================================================================
--- trunk/OpenMPT/mptrack/mptrack_10.vcxproj	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/mptrack/mptrack_10.vcxproj	2012-02-06 23:55:02 UTC (rev 1172)
@@ -329,6 +329,7 @@
     <ClInclude Include="..\common\typedefs.h" />
     <ClInclude Include="..\soundlib\MIDIMacros.h" />
     <ClInclude Include="..\soundlib\PluginMixBuffer.h" />
+    <ClInclude Include="..\soundlib\PlugInterface.h" />
     <ClInclude Include="ACMConvert.h" />
     <ClInclude Include="Autotune.h" />
     <ClInclude Include="ExceptionHandler.h" />

Modified: trunk/OpenMPT/mptrack/mptrack_10.vcxproj.filters
===================================================================
--- trunk/OpenMPT/mptrack/mptrack_10.vcxproj.filters	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/mptrack/mptrack_10.vcxproj.filters	2012-02-06 23:55:02 UTC (rev 1172)
@@ -774,6 +774,9 @@
     <ClInclude Include="..\soundlib\PluginMixBuffer.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="..\soundlib\PlugInterface.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="res\bitmap1.bmp">

Modified: trunk/OpenMPT/mptrack/test/test.cpp
===================================================================
--- trunk/OpenMPT/mptrack/test/test.cpp	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/mptrack/test/test.cpp	2012-02-06 23:55:02 UTC (rev 1172)
@@ -283,9 +283,9 @@
 	VERIFY_EQUAL_NONCONT(pSndFile->m_nRestartPos, 1);
 
 	// Macros
-	VERIFY_EQUAL_NONCONT(MIDIMacroTools::GetMacroType(pSndFile->m_MidiCfg.szMidiSFXExt[0]), sfx_reso);
-	VERIFY_EQUAL_NONCONT(MIDIMacroTools::GetMacroType(pSndFile->m_MidiCfg.szMidiSFXExt[1]), sfx_drywet);
-	VERIFY_EQUAL_NONCONT(MIDIMacroTools::GetZxxType(pSndFile->m_MidiCfg.szMidiZXXExt), zxx_resomode);
+	VERIFY_EQUAL_NONCONT(pSndFile->m_MidiCfg.GetParameteredMacroType(0, sfx_reso);
+	VERIFY_EQUAL_NONCONT(pSndFile->m_MidiCfg.GetParameteredMacroType(1, sfx_drywet);
+	VERIFY_EQUAL_NONCONT(pSndFile->m_MidiCfg.GetFixedMacroType(), zxx_resomode);
 
 	// Channels
 	VERIFY_EQUAL_NONCONT(pSndFile->GetNumChannels(), 2);
@@ -478,9 +478,9 @@
 	VERIFY_EQUAL_NONCONT((uint32)((double)fh.openTime / HISTORY_TIMER_PRECISION), 31);
 
 	// Macros
-	VERIFY_EQUAL_NONCONT(MIDIMacroTools::GetMacroType(pSndFile->m_MidiCfg.szMidiSFXExt[0]), sfx_reso);
-	VERIFY_EQUAL_NONCONT(MIDIMacroTools::GetMacroType(pSndFile->m_MidiCfg.szMidiSFXExt[1]), sfx_drywet);
-	VERIFY_EQUAL_NONCONT(MIDIMacroTools::GetZxxType(pSndFile->m_MidiCfg.szMidiZXXExt), zxx_resomode);
+	VERIFY_EQUAL_NONCONT(pSndFile->m_MidiCfg.GetParameteredMacroType(0, sfx_reso);
+	VERIFY_EQUAL_NONCONT(pSndFile->m_MidiCfg.GetParameteredMacroType(1, sfx_drywet);
+	VERIFY_EQUAL_NONCONT(pSndFile->m_MidiCfg.GetFixedMacroType(), zxx_resomode);
 
 	// Channels
 	VERIFY_EQUAL_NONCONT(pSndFile->GetNumChannels(), 2);

Modified: trunk/OpenMPT/soundlib/Load_it.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_it.cpp	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/soundlib/Load_it.cpp	2012-02-06 23:55:02 UTC (rev 1172)
@@ -812,11 +812,11 @@
 	// Reading MIDI Output & Macros
 	if (m_dwSongFlags & SONG_EMBEDMIDICFG)
 	{
-		if (dwMemPos + sizeof(MODMIDICFG) < dwMemLength)
+		if (dwMemPos + sizeof(MIDIMacroConfig) < dwMemLength)
 		{
-			memcpy(&m_MidiCfg, lpStream + dwMemPos, sizeof(MODMIDICFG));
-			SanitizeMacros();
-			dwMemPos += sizeof(MODMIDICFG);
+			memcpy(&m_MidiCfg, lpStream + dwMemPos, sizeof(MIDIMacroConfig));
+			m_MidiCfg.Sanitize();
+			dwMemPos += sizeof(MIDIMacroConfig);
 		}
 	}
 	// Ignore MIDI data. Fixes some files like denonde.it that were made with old versions of Impulse Tracker (which didn't support Zxx filters) and have Zxx effects in the patterns.
@@ -1491,7 +1491,7 @@
 	{
 		header.flags |= 0x80;
 		header.special |= 0x08;
-		dwExtra += sizeof(MODMIDICFG);
+		dwExtra += sizeof(MIDIMacroConfig);
 	}
 
 	// Pattern Names
@@ -1531,7 +1531,7 @@
 	// Writing midi cfg
 	if (header.flags & 0x80)
 	{
-		fwrite(&m_MidiCfg, 1, sizeof(MODMIDICFG), f);
+		fwrite(&m_MidiCfg, 1, sizeof(MIDIMacroConfig), f);
 	}
 
 	// Writing pattern names

Modified: trunk/OpenMPT/soundlib/Load_itp.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_itp.cpp	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/soundlib/Load_itp.cpp	2012-02-06 23:55:02 UTC (rev 1172)
@@ -176,7 +176,7 @@
 	if (id <= sizeof(m_MidiCfg))
 	{
 		memcpy(&m_MidiCfg, lpStream + dwMemPos, id);
-		SanitizeMacros();
+		m_MidiCfg.Sanitize();
 		dwMemPos += id;
 	}
 
@@ -552,11 +552,11 @@
 	// Song midi config
 
 	// midi cfg data length
-	id = sizeof(MODMIDICFG);
+	id = sizeof(MIDIMacroConfig);
 	fwrite(&id, 1, sizeof(id), f);
 
 	// midi cfg
-	fwrite(&m_MidiCfg, 1, sizeof(MODMIDICFG), f);
+	fwrite(&m_MidiCfg, 1, sizeof(MIDIMacroConfig), f);
 
 	// Song Instruments
 

Modified: trunk/OpenMPT/soundlib/Load_xm.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_xm.cpp	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/soundlib/Load_xm.cpp	2012-02-06 23:55:02 UTC (rev 1172)
@@ -609,10 +609,10 @@
 	{
 		UINT len = *((DWORD *)(lpStream+dwMemPos+4));
 		dwMemPos += 8;
-		if (len == sizeof(MODMIDICFG))
+		if (len == sizeof(MIDIMacroConfig))
 		{
 			memcpy(&m_MidiCfg, lpStream + dwMemPos, len);
-			SanitizeMacros();
+			m_MidiCfg.Sanitize();
 			m_dwSongFlags |= SONG_EMBEDMIDICFG;
 			dwMemPos += len;	//rewbs.fix36946
 		}
@@ -1092,9 +1092,9 @@
 		{
 			DWORD d = 0x4944494D;
 			fwrite(&d, 1, 4, f);
-			d = sizeof(MODMIDICFG);
+			d = sizeof(MIDIMacroConfig);
 			fwrite(&d, 1, 4, f);
-			fwrite(&m_MidiCfg, 1, sizeof(MODMIDICFG), f);
+			fwrite(&m_MidiCfg, 1, sizeof(MIDIMacroConfig), f);
 		}
 		// Writing Pattern Names
 		const PATTERNINDEX numNamedPats = Patterns.GetNumNamedPatterns();

Modified: trunk/OpenMPT/soundlib/MIDIMacros.cpp
===================================================================
--- trunk/OpenMPT/soundlib/MIDIMacros.cpp	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/soundlib/MIDIMacros.cpp	2012-02-06 23:55:02 UTC (rev 1172)
@@ -8,51 +8,169 @@
 
 #include "stdafx.h"
 #include "midi.h"
+#include "MIDIMacros.h"
+#include "../common/StringFixer.h"
+
+#ifdef MODPLUG_TRACKER
 #include "Sndfile.h"
-#include "MIDIMacros.h"
-#ifndef NO_VST
 #include "../mptrack/Vstplug.h"
-#endif // NO_VST
+#endif // MODPLUG_TRACKER
 
+parameteredMacroType MIDIMacroConfig::GetParameteredMacroType(size_t macroIndex) const
+//------------------------------------------------------------------------------------
+{
+	const std::string macro = GetSafeMacro(szMidiSFXExt[macroIndex]);
 
-enmParameteredMacroType MIDIMacroTools::GetMacroType(CString value)
-//-----------------------------------------------------------------
-{
-	value.Remove(' ');
 	for(size_t i = 0; i < sfx_max; i++)
 	{
-		enmParameteredMacroType sfx = static_cast<enmParameteredMacroType>(i);
+		parameteredMacroType sfx = static_cast<parameteredMacroType>(i);
 		if(sfx != sfx_custom)
 		{
-			if(value.Compare(CreateParameteredMacroFromType(sfx)) == 0) return sfx;
+			if(macro.compare(CreateParameteredMacro(sfx)) == 0) return sfx;
 		}
 	}
+
 	// Special macros with additional "parameter":
-	if (value.Compare(CreateParameteredMacroFromType(sfx_cc, MIDICC_start)) >= 0 && value.Compare(CreateParameteredMacroFromType(sfx_cc, MIDICC_end)) <= 0 && value.GetLength() == 5)
+	if (macro.compare(CreateParameteredMacro(sfx_cc, MIDICC_start)) >= 0 && macro.compare(CreateParameteredMacro(sfx_cc, MIDICC_end)) <= 0 && macro.size() == 5)
 		return sfx_cc;
-	if (value.Compare(CreateParameteredMacroFromType(sfx_plug, 0)) >= 0 && value.Compare(CreateParameteredMacroFromType(sfx_plug, 0x17F)) <= 0 && value.GetLength() == 7)
+	if (macro.compare(CreateParameteredMacro(sfx_plug, 0)) >= 0 && macro.compare(CreateParameteredMacro(sfx_plug, 0x17F)) <= 0 && macro.size() == 7)
 		return sfx_plug; 
+
 	return sfx_custom;	// custom / unknown
 }
 
 
+// Retrieve Zxx (Z80-ZFF) type from current macro configuration
+fixedMacroType MIDIMacroConfig::GetFixedMacroType() const
+//-------------------------------------------------------
+{
+	// Compare with all possible preset patterns
+	for(size_t i = 1; i < zxx_max; i++)
+	{
+		// Prepare macro pattern to compare
+		char macros[128][MACRO_LENGTH];
+		CreateFixedMacro(macros, static_cast<fixedMacroType>(i));
+
+		bool bFound = true;
+		for(size_t j = 0; j < 128; j++)
+		{
+			if(strncmp(macros[j], szMidiZXXExt[j], MACRO_LENGTH))
+			{
+				bFound = false;
+				break;
+			}
+		}
+		if(bFound) return static_cast<fixedMacroType>(i);
+	}
+	return zxx_custom; // Custom setup
+}
+
+
+void MIDIMacroConfig::CreateParameteredMacro(char (&parameteredMacro)[MACRO_LENGTH], parameteredMacroType macroType, int subType) const
+//-------------------------------------------------------------------------------------------------------------------------------------
+{
+	switch(macroType)
+	{
+	case sfx_unused:
+		strcpy(parameteredMacro, "");
+		break;
+	case sfx_cutoff:
+		strcpy(parameteredMacro, "F0F000z");
+		break;
+	case sfx_reso:
+		strcpy(parameteredMacro, "F0F001z");
+		break;
+	case sfx_mode:
+		strcpy(parameteredMacro, "F0F002z");
+		break;
+	case sfx_drywet:
+		strcpy(parameteredMacro, "F0F003z");
+		break;
+	case sfx_cc:
+		sprintf(parameteredMacro, "Bc%02Xz", (subType & 0x7F));
+		break;
+	case sfx_plug:
+		sprintf(parameteredMacro, "F0F%03Xz", min(subType, 0x17F) + 0x80);
+		break;
+	case sfx_channelAT:
+		strcpy(parameteredMacro, "Dcz");
+		break;
+	case sfx_polyAT:
+		strcpy(parameteredMacro, "Acnz");
+		break;
+	}
+}
+
+
+// Create Zxx (Z80 - ZFF) from one out of five presets
+void MIDIMacroConfig::CreateFixedMacro(char (&fixedMacros)[128][MACRO_LENGTH], fixedMacroType macroType) const
+//------------------------------------------------------------------------------------------------------------
+{
+	for(size_t i = 0; i < 128; i++)
+	{
+		switch(macroType)
+		{
+		case zxx_reso4Bit:
+			// Type 1 - Z80 - Z8F controls resonance
+			if (i < 16) sprintf(fixedMacros[i], "F0F001%02X", i * 8);
+			else strcpy(fixedMacros[i], "");
+			break;
+
+		case zxx_reso7Bit:
+			// Type 2 - Z80 - ZFF controls resonance
+			sprintf(fixedMacros[i], "F0F001%02X", i);
+			break;
+
+		case zxx_cutoff:
+			// Type 3 - Z80 - ZFF controls cutoff
+			sprintf(fixedMacros[i], "F0F000%02X", i);
+			break;
+
+		case zxx_mode:
+			// Type 4 - Z80 - ZFF controls filter mode
+			sprintf(fixedMacros[i], "F0F002%02X", i);
+			break;
+
+		case zxx_resomode:
+			// Type 5 - Z80 - Z9F controls resonance + filter mode
+			if (i < 16) sprintf(fixedMacros[i], "F0F001%02X", i * 8);
+			else if (i < 32) sprintf(fixedMacros[i], "F0F002%02X", (i - 16) * 8);
+			else strcpy(fixedMacros[i], "");
+			break;
+
+		case zxx_channelAT:
+			// Type 6 - Z80 - ZFF controls Channel Aftertouch
+			sprintf(fixedMacros[i], "Dc%02X", i);
+			break;
+
+		case zxx_polyAT:
+			// Type 7 - Z80 - ZFF controls Poly Aftertouch
+			sprintf(fixedMacros[i], "Acn%02X", i);
+			break;
+		}
+	}
+}
+
+
+#ifdef MODPLUG_TRACKER
+
 // Returns macro description including plugin parameter / MIDI CC information
-CString MIDIMacroTools::GetMacroName(CString value, PLUGINDEX plugin) const
-//-------------------------------------------------------------------------
+CString MIDIMacroConfig::GetParameteredMacroName(size_t macroIndex, PLUGINDEX plugin, const CSoundFile &sndFile) const
+//--------------------------------------------------------------------------------------------------------------------
 {
-	const enmParameteredMacroType macroType = GetMacroType(value);
+	const parameteredMacroType macroType = GetParameteredMacroType(macroIndex);
 
 	switch(macroType)
 	{
 	case sfx_plug:
 		{
-			const int param = MacroToPlugParam(value);
+			const int param = MacroToPlugParam(macroIndex);
 			CString paramName;
 
 #ifndef NO_VST
 			if(plugin < MAX_MIXPLUGINS)
 			{
-				CVstPlugin *pPlug = reinterpret_cast<CVstPlugin *>(m_SndFile.m_MixPlugins[plugin].pMixPlugin);
+				CVstPlugin *pPlug = reinterpret_cast<CVstPlugin *>(sndFile.m_MixPlugins[plugin].pMixPlugin);
 				if(pPlug)
 				{
 					paramName = pPlug->GetParamName(param);
@@ -64,7 +182,7 @@
 
 				CString formattedName;
 				formattedName.Format(_T("Param %d (%s)"), param, paramName);
-				return CString(formattedName);
+				return formattedName;
 			} else
 #endif // NO_VST
 			{
@@ -75,21 +193,21 @@
 	case sfx_cc:
 		{
 			CString formattedCC;
-			formattedCC.Format(_T("MIDI CC %d"), MacroToMidiCC(value));
+			formattedCC.Format(_T("MIDI CC %d"), MacroToMidiCC(macroIndex));
 			return formattedCC;
 		}
 
 	default:
-		return GetMacroName(macroType);
+		return GetParameteredMacroName(macroType);
 	}
 }
 
 
 // Returns generic macro description.
-CString MIDIMacroTools::GetMacroName(enmParameteredMacroType macro)
-//-----------------------------------------------------------------
+CString MIDIMacroConfig::GetParameteredMacroName(parameteredMacroType macroType) const
+//------------------------------------------------------------------------------------
 {
-	switch(macro)
+	switch(macroType)
 	{
 	case sfx_unused:
 		return _T("Unused");
@@ -117,10 +235,10 @@
 
 
 // Returns generic macro description.
-CString MIDIMacroTools::GetZxxName(enmFixedMacroType macro)
-//---------------------------------------------------------
+CString MIDIMacroConfig::GetFixedMacroName(fixedMacroType macroType) const
+//------------------------------------------------------------------------
 {
-	switch(macro)
+	switch(macroType)
 	{
 	case zxx_reso4Bit:
 		return _T("Z80 - Z8F controls Resonant Filter Resonance");
@@ -143,31 +261,33 @@
 }
 
 
-int MIDIMacroTools::MacroToPlugParam(CString macro)
-//-------------------------------------------------
+int MIDIMacroConfig::MacroToPlugParam(size_t macroIndex) const
+//------------------------------------------------------------
 {
-	macro.Remove(' ');
-	int code=0;
-	char* param = (char *) (LPCTSTR) macro;
+	const std::string macro = GetSafeMacro(szMidiSFXExt[macroIndex]);
+
+	int code = 0;
+	const char *param = macro.c_str();
 	param += 4;
 	if ((param[0] >= '0') && (param[0] <= '9')) code = (param[0] - '0') << 4; else
 		if ((param[0] >= 'A') && (param[0] <= 'F')) code = (param[0] - 'A' + 0x0A) << 4;
 	if ((param[1] >= '0') && (param[1] <= '9')) code += (param[1] - '0'); else
 		if ((param[1] >= 'A') && (param[1] <= 'F')) code += (param[1] - 'A' + 0x0A);
 
-	if (macro.GetLength() >= 4 && macro.GetAt(3) == '0')
+	if (macro.size() >= 4 && macro.at(3) == '0')
 		return (code - 128);
 	else
 		return (code + 128);
 }
 
 
-int MIDIMacroTools::MacroToMidiCC(CString macro)
-//----------------------------------------------
+int MIDIMacroConfig::MacroToMidiCC(size_t macroIndex) const
+//---------------------------------------------------------
 {
-	macro.Remove(' ');
-	int code=0;
-	char* param = (char *) (LPCTSTR) macro;
+	const std::string macro = GetSafeMacro(szMidiSFXExt[macroIndex]);
+
+	int code = 0;
+	const char *param = macro.c_str();
 	param += 2;
 	if ((param[0] >= '0') && (param[0] <= '9')) code = (param[0] - '0') << 4; else
 		if ((param[0] >= 'A') && (param[0] <= 'F')) code = (param[0] - 'A' + 0x0A) << 4;
@@ -178,161 +298,101 @@
 }
 
 
-int MIDIMacroTools::FindMacroForParam(long param) const
-//-----------------------------------------------------
+int MIDIMacroConfig::FindMacroForParam(PlugParamIndex param) const
+//----------------------------------------------------------------
 {
-	for (size_t macro = 0; macro < NUM_MACROS; macro++)
+	for(size_t macroIndex = 0; macroIndex < NUM_MACROS; macroIndex++)
 	{
-		CString macroString = m_SndFile.m_MidiCfg.szMidiSFXExt[macro];
-		if (GetMacroType(macroString) == sfx_plug && MacroToPlugParam(macroString) == param)
+		if (GetParameteredMacroType(macroIndex) == sfx_plug && MacroToPlugParam(macroIndex) == param)
 		{
-			return macro;
+			return macroIndex;
 		}
 	}
 
 	return -1;
 }
 
+#endif // MODPLUG_TRACKER
 
-// Retrieve Zxx (Z80-ZFF) type from current macro configuration
-enmFixedMacroType MIDIMacroTools::GetZxxType(const char (&szMidiZXXExt)[128][MACRO_LENGTH])
-//-----------------------------------------------------------------------------------------
+
+// Check if the MIDI Macro configuration used is the default one,
+// i.e. the configuration that is assumed when loading a file that has no macros embedded.
+bool MIDIMacroConfig::IsMacroDefaultSetupUsed() const
+//---------------------------------------------------
 {
-	// Compare with all possible preset patterns
-	for(size_t i = 1; i < zxx_max; i++)
+	const MIDIMacroConfig defaultConfig;
+
+	// TODO - Global macros (currently not checked because they are not editable)
+
+	// SF0: Z00-Z7F controls cutoff, all other parametered macros are unused
+	for(size_t i = 0; i < NUM_MACROS; i++)
 	{
-		// Prepare pattern to compare
-		char szPatterns[128][MACRO_LENGTH];
-		CreateZxxFromType(szPatterns, static_cast<enmFixedMacroType>(i));
-
-		bool bFound = true;
-		for(size_t j = 0; j < 128; j++)
+		if(GetParameteredMacroType(i) != defaultConfig.GetParameteredMacroType(i))
 		{
-			if(strncmp(szPatterns[j], szMidiZXXExt[j], MACRO_LENGTH))
-			{
-				bFound = false;
-				break;
-			}
+			return false;
 		}
-		if(bFound) return static_cast<enmFixedMacroType>(i);
 	}
-	return zxx_custom; // Custom setup
-}
 
-
-// Create Zxx (Z80 - ZFF) from one out of five presets
-void MIDIMacroTools::CreateZxxFromType(char (&szMidiZXXExt)[128][MACRO_LENGTH], enmFixedMacroType iZxxType)
-//---------------------------------------------------------------------------------------------------------
-{
-	for(size_t i = 0; i < 128; i++)
+	// Z80-Z8F controls resonance
+	if(GetFixedMacroType() != defaultConfig.GetFixedMacroType())
 	{
-		switch(iZxxType)
-		{
-		case zxx_reso4Bit:
-			// Type 1 - Z80 - Z8F controls resonance
-			if (i < 16) wsprintf(szMidiZXXExt[i], "F0F001%02X", i * 8);
-			else strcpy(szMidiZXXExt[i], "");
-			break;
+		return false;
+	}
 
-		case zxx_reso7Bit:
-			// Type 2 - Z80 - ZFF controls resonance
-			wsprintf(szMidiZXXExt[i], "F0F001%02X", i);
-			break;
+	return true;
+}
 
-		case zxx_cutoff:
-			// Type 3 - Z80 - ZFF controls cutoff
-			wsprintf(szMidiZXXExt[i], "F0F000%02X", i);
-			break;
 
-		case zxx_mode:
-			// Type 4 - Z80 - ZFF controls filter mode
-			wsprintf(szMidiZXXExt[i], "F0F002%02X", i);
-			break;
+// Reset MIDI macro config to default values.
+void MIDIMacroConfig::Reset()
+//---------------------------
+{
+	MemsetZero(szMidiGlb);
+	MemsetZero(szMidiSFXExt);
+	MemsetZero(szMidiZXXExt);
 
-		case zxx_resomode:
-			// Type 5 - Z80 - Z9F controls resonance + filter mode
-			if (i < 16) wsprintf(szMidiZXXExt[i], "F0F001%02X", i * 8);
-			else if (i < 32) wsprintf(szMidiZXXExt[i], "F0F002%02X", (i - 16) * 8);
-			else strcpy(szMidiZXXExt[i], "");
-			break;
-
-		case zxx_channelAT:
-			// Type 6 - Z80 - ZFF controls Channel Aftertouch
-			wsprintf(szMidiZXXExt[i], "Dc%02X", i);
-			break;
-
-		case zxx_polyAT:
-			// Type 7 - Z80 - ZFF controls Poly Aftertouch
-			wsprintf(szMidiZXXExt[i], "Acn%02X", i);
-			break;
-		}
-	}
+	strcpy(szMidiGlb[MIDIOUT_START], "FF");
+	strcpy(szMidiGlb[MIDIOUT_STOP], "FC");
+	strcpy(szMidiGlb[MIDIOUT_NOTEON], "9c n v");
+	strcpy(szMidiGlb[MIDIOUT_NOTEOFF], "9c n 0");
+	strcpy(szMidiGlb[MIDIOUT_PROGRAM], "Cc p");
+	// SF0: Z00-Z7F controls cutoff
+	CreateParameteredMacro(0, sfx_cutoff);
+	// Z80-Z8F controls resonance
+	CreateFixedMacro(zxx_reso4Bit);
 }
 
 
-CString MIDIMacroTools::CreateParameteredMacroFromType(enmParameteredMacroType type, int subType)
-//-----------------------------------------------------------------------------------------------
+// Sanitize all macro config strings.
+void MIDIMacroConfig::Sanitize()
+//------------------------------
 {
-	CString result;
-
-	switch(type)
+	for(size_t i = 0; i < CountOf(szMidiGlb); i++)
 	{
-	case sfx_unused:
-		result = "";
-		break;
-	case sfx_cutoff:
-		result = "F0F000z";
-		break;
-	case sfx_reso:
-		result = "F0F001z";
-		break;
-	case sfx_mode:
-		result = "F0F002z";
-		break;
-	case sfx_drywet:
-		result = "F0F003z";
-		break;
-	case sfx_cc:
-		result.Format("Bc%02Xz", subType);
-		break;
-	case sfx_plug:
-		result.Format("F0F%03Xz", subType + 0x80);
-		break;
-	case sfx_channelAT:
-		result.Format("Dcz");
-		break;
-	case sfx_polyAT:
-		result.Format("Acnz");
-		break;
+		StringFixer::FixNullString(szMidiGlb[i]);
 	}
-	return result;
+	for(size_t i = 0; i < CountOf(szMidiSFXExt); i++)
+	{
+		StringFixer::FixNullString(szMidiSFXExt[i]);
+	}
+	for(size_t i = 0; i < CountOf(szMidiZXXExt); i++)
+	{
+		StringFixer::FixNullString(szMidiZXXExt[i]);
+	}
 }
 
 
-// Check if the MIDI Macro configuration used is the default one,
-// i.e. the configuration that is assumed when loading a file that has no macros embedded.
-bool MIDIMacroTools::IsMacroDefaultSetupUsed() const
-//--------------------------------------------------
+// Remove blanks and other unwanted characters from macro strings for internal usage.
+std::string MIDIMacroConfig::GetSafeMacro(const char *macro) const
+//----------------------------------------------------------------
 {
-	// TODO - Global macros
+	std::string sanitizedMacro = std::string(macro);
 
-	// SF0: Z00-Z7F controls cutoff
-	if(GetMacroType(m_SndFile.m_MidiCfg.szMidiSFXExt[0]) != sfx_cutoff)
+	std::string::size_type pos;
+	while((pos = sanitizedMacro.find_first_not_of("0123456789ABCDEFabpcnuvxyz")) != std::string::npos)
 	{
-		return false;
+		sanitizedMacro.erase(pos, 1);
 	}
-	// Z80-Z8F controls resonance
-	if(GetZxxType(m_SndFile.m_MidiCfg.szMidiZXXExt) != zxx_reso4Bit)
-	{
-		return false;
-	}
-	// All other parametered macros are unused
-	for(size_t i = 1; i < NUM_MACROS; i++)
-	{
-		if(GetMacroType(m_SndFile.m_MidiCfg.szMidiSFXExt[i]) != sfx_unused)
-		{
-			return false;
-		}
-	}
-	return true;
+
+	return sanitizedMacro;
 }

Modified: trunk/OpenMPT/soundlib/MIDIMacros.h
===================================================================
--- trunk/OpenMPT/soundlib/MIDIMacros.h	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/soundlib/MIDIMacros.h	2012-02-06 23:55:02 UTC (rev 1172)
@@ -10,8 +10,14 @@
 #ifndef MIDIMACROS_H
 #define MIDIMACROS_H
 
-// parametered macro presets:
-enum enmParameteredMacroType
+#ifdef MODPLUG_TRACKER
+class CSoundFile;
+#include "PlugInterface.h"
+#include "Snd_defs.h"
+#endif // MODPLUG_TRACKER
+
+// Parametered macro presets
+enum parameteredMacroType
 {
 	sfx_unused = 0,
 	sfx_cutoff,			// Type 1 - Z00 - Z7F controls resonant filter cutoff
@@ -28,8 +34,8 @@
 };
 
 
-// fixed macro presets:
-enum enmFixedMacroType
+// Fixed macro presets
+enum fixedMacroType
 {
 	zxx_custom = 0,
 	zxx_reso4Bit,		// Type 1 - Z80 - Z8F controls resonant filter resonance
@@ -44,36 +50,94 @@
 };
 
 
-class MIDIMacroTools
+// Global macro types
+enum
 {
-protected:
-	CSoundFile &m_SndFile;
+	MIDIOUT_START = 0,
+	MIDIOUT_STOP,
+	MIDIOUT_TICK,
+	MIDIOUT_NOTEON,
+	MIDIOUT_NOTEOFF,
+	MIDIOUT_VOLUME,
+	MIDIOUT_PAN,
+	MIDIOUT_BANKSEL,
+	MIDIOUT_PROGRAM,
+};
 
+
+#define NUM_MACROS 16	// number of parametered macros
+#define MACRO_LENGTH 32	// max number of chars per macro
+
+//===================
+class MIDIMacroConfig
+//===================
+{
+
 public:
+
+	char szMidiGlb[9][MACRO_LENGTH];		// Global MIDI macros
+	char szMidiSFXExt[16][MACRO_LENGTH];	// Parametric MIDI macros
+	char szMidiZXXExt[128][MACRO_LENGTH];	// Fixed MIDI macros
+
+public:
+
+	MIDIMacroConfig() { Reset(); };
+
 	// Get macro type from a macro string
-	static enmParameteredMacroType GetMacroType(CString value);
-	static enmFixedMacroType GetZxxType(const char (&szMidiZXXExt)[128][MACRO_LENGTH]);
+	parameteredMacroType GetParameteredMacroType(size_t macroIndex) const;
+	fixedMacroType GetFixedMacroType() const;
 
+	// Create a new macro
+	void CreateParameteredMacro(char (&parameteredMacro)[MACRO_LENGTH], parameteredMacroType macroType, int subType) const;
+	void CreateParameteredMacro(size_t macroIndex, parameteredMacroType macroType, int subType = 0)
+	{
+		CreateParameteredMacro(szMidiSFXExt[macroIndex], macroType, subType);
+	};
+	std::string CreateParameteredMacro(parameteredMacroType macroType, int subType = 0) const
+	{
+		char parameteredMacro[MACRO_LENGTH];
+		CreateParameteredMacro(parameteredMacro, macroType, subType);
+		return std::string(parameteredMacro);
+	};
+
+	void CreateFixedMacro(char (&fixedMacros)[128][MACRO_LENGTH], fixedMacroType macroType) const;
+	void CreateFixedMacro(fixedMacroType macroType)
+	{
+		CreateFixedMacro(szMidiZXXExt, macroType);
+	};
+
+#ifdef MODPLUG_TRACKER
+
 	// Translate macro type or macro string to macro name
-	static CString GetMacroName(enmParameteredMacroType macro);
-	CString GetMacroName(CString value, PLUGINDEX plugin) const;
-	static CString GetZxxName(enmFixedMacroType macro);
+	CString GetParameteredMacroName(size_t macroIndex, PLUGINDEX plugin, const CSoundFile &sndFile) const;
+	CString GetParameteredMacroName(parameteredMacroType macroType) const;
+	CString GetFixedMacroName(fixedMacroType macroType) const;
 
-	// Extract information from a macro string.
-	static int MacroToPlugParam(CString value);
-	static int MacroToMidiCC(CString value);
+	// Extract information from a parametered macro string.
+	int MacroToPlugParam(size_t macroIndex) const;
+	int MacroToMidiCC(size_t macroIndex) const;
 
 	// Check if any macro can automate a given plugin parameter
-	int FindMacroForParam(long param) const;
+	int FindMacroForParam(PlugParamIndex param) const;
 
-	// Create a new macro
-	static void CreateZxxFromType(char (&szMidiZXXExt)[128][MACRO_LENGTH], enmFixedMacroType iZxxType);
-	static CString CreateParameteredMacroFromType(enmParameteredMacroType type, int subType = 0);
-	
+#endif // MODPLUG_TRACKER
+
 	// Check if a given set of macros is the default IT macro set.
 	bool IsMacroDefaultSetupUsed() const;
 
-	MIDIMacroTools(CSoundFile &sndFile) : m_SndFile(sndFile) { };
+	// Reset MIDI macro config to default values.
+	void Reset();
+
+	// Sanitize all macro config strings.
+	void Sanitize();
+
+protected:
+
+	// Remove blanks and other unwanted characters from macro strings for internal usage.
+	std::string GetSafeMacro(const char *macro) const;
+
 };
 
+STATIC_ASSERT(sizeof(MIDIMacroConfig) == 4896); // this is directly written to files, so the size must be correct!
+
 #endif // MIDIMACROS_H

Added: trunk/OpenMPT/soundlib/PlugInterface.h
===================================================================
--- trunk/OpenMPT/soundlib/PlugInterface.h	                        (rev 0)
+++ trunk/OpenMPT/soundlib/PlugInterface.h	2012-02-06 23:55:02 UTC (rev 1172)
@@ -0,0 +1,138 @@
+/*
+ * PlugInterface.h
+ * ---------------
+ * Purpose: Interface class and helpers for plugin handling
+ * Notes  : (currently none)
+ * Authors: OpenMPT Devs
+ */
+
+#pragma once
+#ifndef PLUGINTERFACE_H
+#define PLUGINTERFACE_H
+
+// For VstInt32 and stuff - a stupid workaround.
+#ifndef NO_VST
+#define VST_FORCE_DEPRECATED 0
+#include <aeffect.h>			// VST
+#else
+typedef int32 VstInt32;
+typedef intptr_t VstIntPtr;
+#endif
+
+#include "../common/misc_util.h"
+
+////////////////////////////////////////////////////////////////////
+// Mix Plugins
+
+#define MIXPLUG_MIXREADY			0x01	// Set when cleared
+
+typedef VstInt32 PlugParamIndex;
+typedef float PlugParamValue;
+
+//==============
+class IMixPlugin
+//==============
+{
+public:
+	virtual int AddRef() = 0;
+	virtual int Release() = 0;
+	virtual void SaveAllParameters() = 0;
+	virtual void RestoreAllParameters(long nProg=-1) = 0; //rewbs.plugDefaultProgram: added param
+	virtual void Process(float *pOutL, float *pOutR, size_t nSamples) = 0;
+	virtual void Init(unsigned long nFreq, int bReset) = 0;
+	virtual bool MidiSend(DWORD dwMidiCode) = 0;
+	virtual void MidiCC(UINT nMidiCh, UINT nController, UINT nParam, UINT trackChannel) = 0;
+	virtual void MidiPitchBend(UINT nMidiCh, int nParam, UINT trackChannel) = 0;
+	virtual void MidiCommand(UINT nMidiCh, UINT nMidiProg, WORD wMidiBank, UINT note, UINT vol, UINT trackChan) = 0;
+	virtual void HardAllNotesOff() = 0;		//rewbs.VSTCompliance
+	virtual void RecalculateGain() = 0;		
+	virtual bool isPlaying(UINT note, UINT midiChn, UINT trackerChn) = 0; //rewbs.VSTiNNA
+	virtual bool MoveNote(UINT note, UINT midiChn, UINT sourceTrackerChn, UINT destTrackerChn) = 0; //rewbs.VSTiNNA
+	virtual void SetParameter(PlugParamIndex paramindex, PlugParamValue paramvalue) = 0;
+	virtual void SetZxxParameter(UINT nParam, UINT nValue) = 0;
+	virtual PlugParamValue GetParameter(PlugParamIndex nIndex) = 0;
+	virtual UINT GetZxxParameter(UINT nParam) = 0; //rewbs.smoothVST 
+	virtual void ModifyParameter(PlugParamIndex nIndex, PlugParamValue diff);
+	virtual void AutomateParameter(PlugParamIndex param) = 0;
+	virtual VstIntPtr Dispatch(VstInt32 opCode, VstInt32 index, VstIntPtr value, void *ptr, float opt) =0; //rewbs.VSTCompliance
+	virtual void NotifySongPlaying(bool) = 0;	//rewbs.VSTCompliance
+	virtual bool IsSongPlaying() = 0;
+	virtual bool IsResumed() = 0;
+	virtual void Resume() = 0;
+	virtual void Suspend() = 0;
+	virtual bool Bypass(bool = true) = 0;
+	virtual bool IsBypassed() const = 0;
+	bool ToggleBypass() { return Bypass(!IsBypassed()); };
+	virtual bool isInstrument() = 0;
+	virtual bool CanRecieveMidiEvents() = 0;
+	virtual void SetDryRatio(UINT param) = 0;
+
+};
+
+
+inline void IMixPlugin::ModifyParameter(PlugParamIndex nIndex, PlugParamValue diff)
+//---------------------------------------------------------------------------------
+{
+	float val = GetParameter(nIndex) + diff;
+	Limit(val, PlugParamValue(0), PlugParamValue(1));
+	SetParameter(nIndex, val);
+}
+
+
+///////////////////////////////////////////////////
+// !!! bits 8 -> 15 reserved for mixing mode !!! //
+///////////////////////////////////////////////////
+#define MIXPLUG_INPUTF_MASTEREFFECT				0x01	// Apply to master mix
+#define MIXPLUG_INPUTF_BYPASS					0x02	// Bypass effect
+#define MIXPLUG_INPUTF_WETMIX					0x04	// Wet Mix (dry added)
+// -> CODE#0028
+// -> DESC="effect plugin mixing mode combo"
+#define MIXPLUG_INPUTF_MIXEXPAND				0x08	// [0%,100%] -> [-200%,200%]
+// -! BEHAVIOUR_CHANGE#0028
+
+
+struct SNDMIXPLUGINSTATE
+{
+	DWORD dwFlags;					// MIXPLUG_XXXX
+	LONG nVolDecayL, nVolDecayR;	// Buffer click removal
+	int *pMixBuffer;				// Stereo effect send buffer
+	float *pOutBufferL;				// Temp storage for int -> float conversion
+	float *pOutBufferR;
+};
+typedef SNDMIXPLUGINSTATE* PSNDMIXPLUGINSTATE;
+
+struct SNDMIXPLUGININFO
+{
+	DWORD dwPluginId1;
+	DWORD dwPluginId2;
+	DWORD dwInputRouting;	// MIXPLUG_INPUTF_XXXX, bits 16-23 = gain
+	DWORD dwOutputRouting;	// 0=mix 0x80+=fx
+	DWORD dwReserved[4];	// Reserved for routing info
+	CHAR szName[32];
+	CHAR szLibraryName[64];	// original DLL name
+}; // Size should be 128 							
+typedef SNDMIXPLUGININFO* PSNDMIXPLUGININFO;
+STATIC_ASSERT(sizeof(SNDMIXPLUGININFO) == 128);	// this is directly written to files, so the size must be correct!
+
+struct SNDMIXPLUGIN
+{
+	const char* GetName() const { return Info.szName; }
+	const char* GetLibraryName();
+	CString GetParamName(const UINT index) const;
+	bool Bypass(bool bypass);
+	bool IsBypassed() const { return (Info.dwInputRouting & MIXPLUG_INPUTF_BYPASS) != 0; };
+
+	IMixPlugin *pMixPlugin;
+	PSNDMIXPLUGINSTATE pMixState;
+	ULONG nPluginDataSize;
+	PVOID pPluginData;
+	SNDMIXPLUGININFO Info;
+	float fDryRatio;		    // rewbs.dryRatio [20040123]
+	long defaultProgram;		// rewbs.plugDefaultProgram
+}; // rewbs.dryRatio: Hopefully this doesn't need to be a fixed size.
+typedef SNDMIXPLUGIN* PSNDMIXPLUGIN;
+
+class CSoundFile;
+typedef	BOOL (__cdecl *PMIXPLUGINCREATEPROC)(PSNDMIXPLUGIN, CSoundFile*);
+
+#endif // PLUGINTERFACE_H

Modified: trunk/OpenMPT/soundlib/Sndfile.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Sndfile.cpp	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/soundlib/Sndfile.cpp	2012-02-06 23:55:02 UTC (rev 1172)
@@ -16,7 +16,6 @@
 #include "sndfile.h"
 #include "wavConverter.h"
 #include "tuningcollection.h"
-#include "MIDIMacros.h"
 #include "../common/StringFixer.h"
 #include <vector>
 #include <list>
@@ -555,7 +554,6 @@
 	//Order.assign(MAX_ORDERS, Order.GetInvalidPatIndex());
 	Order.resize(1);
 	Patterns.ClearPatterns();
-	ResetMidiCfg(m_MidiCfg);
 
 	for (CHANNELINDEX nChn = 0; nChn < MAX_BASECHANNELS; nChn++)
 	{
@@ -913,39 +911,7 @@
 //////////////////////////////////////////////////////////////////////////
 // Misc functions
 
-void CSoundFile::ResetMidiCfg(MODMIDICFG &midiConfig)
-//---------------------------------------------------
-{
-	MemsetZero(midiConfig);
-	strcpy(midiConfig.szMidiGlb[MIDIOUT_START], "FF");
-	strcpy(midiConfig.szMidiGlb[MIDIOUT_STOP], "FC");
-	strcpy(midiConfig.szMidiGlb[MIDIOUT_NOTEON], "9c n v");
-	strcpy(midiConfig.szMidiGlb[MIDIOUT_NOTEOFF], "9c n 0");
-	strcpy(midiConfig.szMidiGlb[MIDIOUT_PROGRAM], "Cc p");
-	strcpy(midiConfig.szMidiSFXExt[0], "F0F000z");
-	MIDIMacroTools::CreateZxxFromType(midiConfig.szMidiZXXExt, zxx_reso4Bit);
-}
 
-
-// Set null terminator for all MIDI macros
-void CSoundFile::SanitizeMacros()
-//-------------------------------
-{
-	for(size_t i = 0; i < CountOf(m_MidiCfg.szMidiGlb); i++)
-	{
-		StringFixer::FixNullString(m_MidiCfg.szMidiGlb[i]);
-	}
-	for(size_t i = 0; i < CountOf(m_MidiCfg.szMidiSFXExt); i++)
-	{
-		StringFixer::FixNullString(m_MidiCfg.szMidiSFXExt[i]);
-	}
-	for(size_t i = 0; i < CountOf(m_MidiCfg.szMidiZXXExt); i++)
-	{
-		StringFixer::FixNullString(m_MidiCfg.szMidiZXXExt[i]);
-	}
-}
-
-
 BOOL CSoundFile::SetWaveConfig(UINT nRate,UINT nBits,UINT nChannels,BOOL bMMX)
 //----------------------------------------------------------------------------
 {
@@ -3117,7 +3083,7 @@
 
 
 // Fix old-format (not conforming to IT's MIDI macro definitions) MIDI config strings.
-void CSoundFile::FixMIDIConfigStrings(MODMIDICFG &midiCfg)
+void CSoundFile::FixMIDIConfigStrings(MIDIMacroConfig &midiCfg)
 //--------------------------------------------------------
 {
 	for(size_t i = 0; i < CountOf(midiCfg.szMidiSFXExt); i++)

Modified: trunk/OpenMPT/soundlib/Sndfile.h
===================================================================
--- trunk/OpenMPT/soundlib/Sndfile.h	2012-02-06 18:26:37 UTC (rev 1171)
+++ trunk/OpenMPT/soundlib/Sndfile.h	2012-02-06 23:55:02 UTC (rev 1172)
@@ -20,15 +20,8 @@
 #include "Snd_defs.h"
 #include "Endianness.h"
 #include "tuning.h"
+#include "MIDIMacros.h"
 
-// For VstInt32 and stuff - a stupid workaround for IMixPlugin.
-#ifndef NO_VST
-#define VST_FORCE_DEPRECATED 0
-#include <aeffect.h>			// VST
-#else
-typedef int32 VstInt32;
-typedef intptr_t VstIntPtr;
-#endif
 
 //class CTuningBase;
 //typedef CTuningBase CTuning;
@@ -424,119 +417,8 @@
 
 #include "modcommand.h"
 
+#include "PlugInterface.h"
 
-////////////////////////////////////////////////////////////////////
-// Mix Plugins
-#define MIXPLUG_MIXREADY			0x01	// Set when cleared
-
-typedef VstInt32 PlugParamIndex;
-typedef float PlugParamValue;
-
-class IMixPlugin
-{
-public:
-	virtual int AddRef() = 0;
-	virtual int Release() = 0;
-	virtual void SaveAllParameters() = 0;
-	virtual void RestoreAllParameters(long nProg=-1) = 0; //rewbs.plugDefaultProgram: added param
-	virtual void Process(float *pOutL, float *pOutR, size_t nSamples) = 0;
-	virtual void Init(unsigned long nFreq, int bReset) = 0;
-	virtual bool MidiSend(DWORD dwMidiCode) = 0;
-	virtual void MidiCC(UINT nMidiCh, UINT nController, UINT nParam, UINT trackChannel) = 0;
-	virtual void MidiPitchBend(UINT nMidiCh, int nParam, UINT trackChannel) = 0;
-	virtual void MidiCommand(UINT nMidiCh, UINT nMidiProg, WORD wMidiBank, UINT note, UINT vol, UINT trackChan) = 0;
-	virtual void HardAllNotesOff() = 0;		//rewbs.VSTCompliance
-	virtual void RecalculateGain() = 0;		
-	virtual bool isPlaying(UINT note, UINT midiChn, UINT trackerChn) = 0; //rewbs.VSTiNNA
-	virtual bool MoveNote(UINT note, UINT midiChn, UINT sourceTrackerChn, UINT destTrackerChn) = 0; //rewbs.VSTiNNA
-	virtual void SetParameter(PlugParamIndex paramindex, PlugParamValue paramvalue) = 0;
-	virtual void SetZxxParameter(UINT nParam, UINT nValue) = 0;
-	virtual PlugParamValue GetParameter(PlugParamIndex nIndex) = 0;
-	virtual UINT GetZxxParameter(UINT nParam) = 0; //rewbs.smoothVST 
-	virtual void ModifyParameter(PlugParamIndex nIndex, PlugParamValue diff);
-	virtual void AutomateParameter(PlugParamIndex param) = 0;
-	virtual VstIntPtr Dispatch(VstInt32 opCode, VstInt32 index, VstIntPtr value, void *ptr, float opt) =0; //rewbs.VSTCompliance
-	virtual void NotifySongPlaying(bool) = 0;	//rewbs.VSTCompliance
-	virtual bool IsSongPlaying() = 0;
-	virtual bool IsResumed() = 0;
-	virtual void Resume() = 0;
-	virtual void Suspend() = 0;
-	virtual bool Bypass(bool = true) = 0;
-	virtual bool IsBypassed() const = 0;
-	bool ToggleBypass() { return Bypass(!IsBypassed()); };
-	virtual bool isInstrument() = 0;
-	virtual bool CanRecieveMidiEvents() = 0;
-	virtual void SetDryRatio(UINT param) = 0;
-
-};
-
-inline void IMixPlugin::ModifyParameter(PlugParamIndex nIndex, PlugParamValue diff)
-//---------------------------------------------------------------------------------
-{
-	float val = GetParameter(nIndex) + diff;
-	Limit(val, PlugParamValue(0), PlugParamValue(1));
-	SetParameter(nIndex, val);
-}
-
-
-												///////////////////////////////////////////////////
-												// !!! bits 8 -> 15 reserved for mixing mode !!! //
-												///////////////////////////////////////////////////
-#define MIXPLUG_INPUTF_MASTEREFFECT				0x01	// Apply to master mix
-#define MIXPLUG_INPUTF_BYPASS					0x02	// Bypass effect
-#define MIXPLUG_INPUTF_WETMIX					0x04	// Wet Mix (dry added)
-// -> CODE#0028
-// -> DESC="effect plugin mixing mode combo"
-#define MIXPLUG_INPUTF_MIXEXPAND				0x08	// [0%,100%] -> [-200%,200%]
-// -! BEHAVIOUR_CHANGE#0028
-
-
-struct SNDMIXPLUGINSTATE
-{
-	DWORD dwFlags;					// MIXPLUG_XXXX
-	LONG nVolDecayL, nVolDecayR;	// Buffer click removal
-	int *pMixBuffer;				// Stereo effect send buffer
-	float *pOutBufferL;				// Temp storage for int -> float conversion
-	float *pOutBufferR;
-};
-typedef SNDMIXPLUGINSTATE* PSNDMIXPLUGINSTATE;
-
-struct SNDMIXPLUGININFO
-{
-	DWORD dwPluginId1;
-	DWORD dwPluginId2;
-	DWORD dwInputRouting;	// MIXPLUG_INPUTF_XXXX, bits 16-23 = gain
-	DWORD dwOutputRouting;	// 0=mix 0x80+=fx
-	DWORD dwReserved[4];	// Reserved for routing info
-	CHAR szName[32];
-	CHAR szLibraryName[64];	// original DLL name
-}; // Size should be 128 							
-typedef SNDMIXPLUGININFO* PSNDMIXPLUGININFO;
-STATIC_ASSERT(sizeof(SNDMIXPLUGININFO) == 128);	// this is directly written to files, so the size must be correct!
-
-struct SNDMIXPLUGIN
-{
-	const char* GetName() const { return Info.szName; }
-	const char* GetLibraryName();
-	CString GetParamName(const U...
 
[truncated message content]