modplug-svn-commit Mailing List for modplug (Page 949)

A music tracker software for Windows.

Brought to you by: lpchip, manxorist, rewbs, saga-games

modplug-svn-commit — OpenMPT subversion commit notifications

You can subscribe to this list here.

2006	Jan	Feb	Mar (1)	Apr (1)	May	Jun (1)	Jul	Aug (10)	Sep	Oct	Nov	Dec (3)
2007	Jan (1)	Feb (2)	Mar (3)	Apr (2)	May (10)	Jun (2)	Jul (1)	Aug	Sep	Oct	Nov (3)	Dec
2008	Jan (6)	Feb (4)	Mar (5)	Apr (2)	May (1)	Jun (1)	Jul (4)	Aug (6)	Sep (2)	Oct (9)	Nov (1)	Dec (4)
2009	Jan (9)	Feb (2)	Mar (2)	Apr (2)	May (6)	Jun (18)	Jul (33)	Aug (39)	Sep (33)	Oct (24)	Nov (23)	Dec (22)
2010	Jan (29)	Feb (32)	Mar (51)	Apr (17)	May (31)	Jun (21)	Jul (32)	Aug (28)	Sep (35)	Oct (27)	Nov (11)	Dec (13)
2011	Jan (14)	Feb (13)	Mar (27)	Apr (27)	May (28)	Jun (20)	Jul (43)	Aug (52)	Sep (66)	Oct (61)	Nov (11)	Dec (8)
2012	Jan (20)	Feb (30)	Mar (38)	Apr (21)	May (33)	Jun (21)	Jul (25)	Aug (9)	Sep (24)	Oct (42)	Nov (27)	Dec (41)
2013	Jan (20)	Feb (35)	Mar (156)	Apr (298)	May (258)	Jun (201)	Jul (105)	Aug (60)	Sep (193)	Oct (245)	Nov (280)	Dec (194)
2014	Jan (63)	Feb (202)	Mar (200)	Apr (23)	May (53)	Jun (105)	Jul (18)	Aug (26)	Sep (110)	Oct (187)	Nov (97)	Dec (74)
2015	Jan (45)	Feb (55)	Mar (116)	Apr (116)	May (193)	Jun (164)	Jul (50)	Aug (111)	Sep (98)	Oct (71)	Nov (103)	Dec (63)
2016	Jan (33)	Feb (101)	Mar (182)	Apr (139)	May (140)	Jun (103)	Jul (165)	Aug (286)	Sep (208)	Oct (127)	Nov (97)	Dec (54)
2017	Jan (64)	Feb (335)	Mar (202)	Apr (212)	May (139)	Jun (127)	Jul (294)	Aug (154)	Sep (170)	Oct (152)	Nov (156)	Dec (62)
2018	Jan (168)	Feb (237)	Mar (196)	Apr (174)	May (174)	Jun (161)	Jul (127)	Aug (88)	Sep (149)	Oct (66)	Nov (52)	Dec (135)
2019	Jan (146)	Feb (126)	Mar (104)	Apr (58)	May (60)	Jun (28)	Jul (197)	Aug (129)	Sep (141)	Oct (148)	Nov (63)	Dec (100)
2020	Jan (74)	Feb (37)	Mar (59)	Apr (154)	May (194)	Jun (133)	Jul (313)	Aug (197)	Sep (49)	Oct (162)	Nov (143)	Dec (57)
2021	Jan (120)	Feb (107)	Mar (314)	Apr (157)	May (524)	Jun (169)	Jul (72)	Aug (133)	Sep (135)	Oct (146)	Nov (198)	Dec (325)
2022	Jan (409)	Feb (249)	Mar (138)	Apr (95)	May (102)	Jun (221)	Jul (66)	Aug (120)	Sep (192)	Oct (131)	Nov (53)	Dec (171)
2023	Jan (357)	Feb (82)	Mar (168)	Apr (218)	May (196)	Jun (86)	Jul (115)	Aug (49)	Sep (190)	Oct (102)	Nov (45)	Dec (76)
2024	Jan (86)	Feb (50)	Mar (324)	Apr (209)	May (197)	Jun (232)	Jul (194)	Aug (247)	Sep (219)	Oct (266)	Nov (328)	Dec (304)
2025	Jan (191)	Feb (115)	Mar (137)	Apr (32)	May (126)	Jun (403)	Jul (213)	Aug	Sep	Oct	Nov	Dec

Flat | Threaded

<< < 1 .. 947 948 949 950 951 .. 957 > >> (Page 949 of 957)

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

From: <rel...@us...> - 2009-09-20 13:04:51

Revision: 370
          http://modplug.svn.sourceforge.net/modplug/?rev=370&view=rev
Author:   relabsoluness
Date:     2009-09-20 13:04:44 +0000 (Sun, 20 Sep 2009)

Log Message:
-----------
[Fix] Pattern tab: Sequence name control wasn't updated properly.
[Mod] Version: Changed version number.

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/Ctrl_pat.cpp
    trunk/OpenMPT/mptrack/version.h

Modified: trunk/OpenMPT/mptrack/Ctrl_pat.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_pat.cpp	2009-09-18 18:48:59 UTC (rev 369)
+++ trunk/OpenMPT/mptrack/Ctrl_pat.cpp	2009-09-20 13:04:44 UTC (rev 370)
@@ -190,6 +190,7 @@
 	SetDlgItemInt(IDC_EDIT_SPACING, CMainFrame::gnPatternSpacing);
 	SetDlgItemInt(IDC_EDIT_ORDERLIST_MARGINS, m_OrderList.GetMargins());
 	CheckDlgButton(IDC_PATTERN_FOLLOWSONG, !(CMainFrame::m_dwPatternSetup & PATTERN_FOLLOWSONGOFF));		//rewbs.noFollow - set to unchecked
+	SetDlgItemText(IDC_EDIT_SEQUENCE_NAME, m_pSndFile->Order.m_sName);
 	m_OrderList.SetFocus(); 
 
 	UpdateView(HINT_MODTYPE|HINT_PATNAMES, NULL);

Modified: trunk/OpenMPT/mptrack/version.h
===================================================================
--- trunk/OpenMPT/mptrack/version.h	2009-09-18 18:48:59 UTC (rev 369)
+++ trunk/OpenMPT/mptrack/version.h	2009-09-20 13:04:44 UTC (rev 370)
@@ -15,7 +15,7 @@
 #define VER_MAJORMAJOR				1
 #define VER_MAJOR					17
 #define VER_MINOR					03
-#define VER_MINORMINOR				01
+#define VER_MINORMINOR				02
 
 //Creates version number from version parts that appears in version string.
 //For example MAKE_VERSION_NUMERIC(1,17,02,28) gives version number of 


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-09-18 18:49:14

Revision: 369
          http://modplug.svn.sourceforge.net/modplug/?rev=369&view=rev
Author:   saga-games
Date:     2009-09-18 18:48:59 +0000 (Fri, 18 Sep 2009)

Log Message:
-----------
[Fix] ITI Loader/Saver: Forgot to change vibrato sweep settings here in the last commit
[Ref] Some more refactoring

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/Moddoc.cpp
    trunk/OpenMPT/mptrack/Moddoc.h
    trunk/OpenMPT/mptrack/View_tre.cpp
    trunk/OpenMPT/soundlib/Sampleio.cpp
    trunk/OpenMPT/soundlib/Sndfile.h

Modified: trunk/OpenMPT/mptrack/Moddoc.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Moddoc.cpp	2009-09-17 16:11:47 UTC (rev 368)
+++ trunk/OpenMPT/mptrack/Moddoc.cpp	2009-09-18 18:48:59 UTC (rev 369)
@@ -1017,13 +1017,13 @@
 }
 
 
-BOOL CModDoc::MuteChannel(UINT nChn, BOOL doMute)
+bool CModDoc::MuteChannel(CHANNELINDEX nChn, bool doMute)
 //----------------------------------------------
 {
 	DWORD muteType = (CMainFrame::m_dwPatternSetup&PATTERN_SYNCMUTE)? CHN_SYNCMUTE:CHN_MUTE;
 
 	if (nChn >= m_SndFile.m_nChannels) {
-		return FALSE;
+		return false;
 	}
 
 	//Mark channel as muted in channel settings
@@ -1067,43 +1067,43 @@
 		CMainFrame::GetMainFrame()->ThreadSafeSetModified(this);
 	}
 
-	return TRUE;
+	return true;
 }
 
 // -> CODE#0012
 // -> DESC="midi keyboard split"
-BOOL CModDoc::IsChannelSolo(UINT nChn) const
-//------------------------------------------
+bool CModDoc::IsChannelSolo(CHANNELINDEX nChn) const
+//--------------------------------------------------
 {
-	if (nChn >= m_SndFile.m_nChannels) return TRUE;
-	return (m_SndFile.ChnSettings[nChn].dwFlags & CHN_SOLO) ? TRUE : FALSE;
+	if (nChn >= m_SndFile.m_nChannels) return true;
+	return (m_SndFile.ChnSettings[nChn].dwFlags & CHN_SOLO) ? true : false;
 }
 
-BOOL CModDoc::SoloChannel(UINT nChn, BOOL bSolo)
-//---------------------------------------------
+bool CModDoc::SoloChannel(CHANNELINDEX nChn, bool bSolo)
+//------------------------------------------------------
 {
-	if (nChn >= m_SndFile.m_nChannels) return FALSE;
+	if (nChn >= m_SndFile.m_nChannels) return false;
 	if (m_SndFile.m_nType & (MOD_TYPE_IT | MOD_TYPE_MPT)) SetModified();
 	if (bSolo)	m_SndFile.ChnSettings[nChn].dwFlags |= CHN_SOLO;
 	else		m_SndFile.ChnSettings[nChn].dwFlags &= ~CHN_SOLO;
-	return TRUE;
+	return true;
 }
 // -! NEW_FEATURE#0012
 
 
 // -> CODE#0015
 // -> DESC="channels management dlg"
-BOOL CModDoc::IsChannelNoFx(UINT nChn) const
+bool CModDoc::IsChannelNoFx(CHANNELINDEX nChn) const
 //------------------------------------------
 {
-	if (nChn >= m_SndFile.m_nChannels) return TRUE;
-	return (m_SndFile.ChnSettings[nChn].dwFlags & CHN_NOFX) ? TRUE : FALSE;
+	if (nChn >= m_SndFile.m_nChannels) return true;
+	return (m_SndFile.ChnSettings[nChn].dwFlags & CHN_NOFX) ? true : false;
 }
 
-BOOL CModDoc::NoFxChannel(UINT nChn, BOOL bNoFx, BOOL updateMix)
-//--------------------------------------------------------------
+bool CModDoc::NoFxChannel(CHANNELINDEX nChn, bool bNoFx, bool updateMix)
+//----------------------------------------------------------------------
 {
-	if (nChn >= m_SndFile.m_nChannels) return FALSE;
+	if (nChn >= m_SndFile.m_nChannels) return false;
 	if (m_SndFile.m_nType & (MOD_TYPE_IT | MOD_TYPE_MPT)) SetModified();
 	if (bNoFx){
 		m_SndFile.ChnSettings[nChn].dwFlags |= CHN_NOFX;
@@ -1113,33 +1113,33 @@
 		m_SndFile.ChnSettings[nChn].dwFlags &= ~CHN_NOFX;
 		if(updateMix) m_SndFile.Chn[nChn].dwFlags &= ~CHN_NOFX;
 	}
-	return TRUE;
+	return true;
 }
 
-BOOL CModDoc::IsChannelRecord1(UINT channel)
-//------------------------------------------
+bool CModDoc::IsChannelRecord1(CHANNELINDEX channel)
+//--------------------------------------------------
 {
 	UINT m = 1 << (channel&7);
-	return (MultiRecordMask[channel>>3] & m) ? TRUE : FALSE;
+	return (MultiRecordMask[channel>>3] & m) ? true : false;
 }
 
-BOOL CModDoc::IsChannelRecord2(UINT channel)
-//------------------------------------------
+bool CModDoc::IsChannelRecord2(CHANNELINDEX channel)
+//--------------------------------------------------
 {
 	UINT m = 1 << (channel&7);
-	return (MultiSplitRecordMask[channel>>3] & m) ? TRUE : FALSE;
+	return (MultiSplitRecordMask[channel>>3] & m) ? true : false;
 }
 
-BYTE CModDoc::IsChannelRecord(UINT channel)
-//-----------------------------------------
+BYTE CModDoc::IsChannelRecord(CHANNELINDEX channel)
+//-------------------------------------------------
 {
 	if(IsChannelRecord1(channel)) return 1;
 	if(IsChannelRecord2(channel)) return 2;
 	return 0;
 }
 
-void CModDoc::Record1Channel(UINT channel, BOOL select)
-//-----------------------------------------------------
+void CModDoc::Record1Channel(CHANNELINDEX channel, bool select)
+//-------------------------------------------------------------
 {
 	UINT m = 1 << (channel&7);
 
@@ -1153,8 +1153,8 @@
 	}
 }
 
-void CModDoc::Record2Channel(UINT channel, BOOL select)
-//-----------------------------------------------------
+void CModDoc::Record2Channel(CHANNELINDEX channel, bool select)
+//-------------------------------------------------------------
 {
 	UINT m = 1 << (channel&7);
 
@@ -1168,7 +1168,7 @@
 	}
 }
 
-void CModDoc::ReinitRecordState(BOOL unselect)
+void CModDoc::ReinitRecordState(bool unselect)
 //--------------------------------------------
 {
 	memset(MultiRecordMask, unselect ? 0 : 0xff, sizeof(MultiRecordMask));
@@ -1177,31 +1177,31 @@
 // -! NEW_FEATURE#0015
 
 
-BOOL CModDoc::MuteSample(UINT nSample, BOOL bMute)
-//------------------------------------------------
+bool CModDoc::MuteSample(SAMPLEINDEX nSample, bool bMute)
+//-------------------------------------------------------
 {
-	if ((nSample < 1) || (nSample > m_SndFile.m_nSamples)) return FALSE;
+	if ((nSample < 1) || (nSample > m_SndFile.m_nSamples)) return false;
 	if (bMute) m_SndFile.Samples[nSample].uFlags |= CHN_MUTE;
 	else m_SndFile.Samples[nSample].uFlags &= ~CHN_MUTE;
-	return TRUE;
+	return true;
 }
 
-BOOL CModDoc::MuteInstrument(UINT nInstr, BOOL bMute)
-//---------------------------------------------------
+bool CModDoc::MuteInstrument(INSTRUMENTINDEX nInstr, bool bMute)
+//--------------------------------------------------------------
 {
-	if ((nInstr < 1) || (nInstr > m_SndFile.m_nInstruments) || (!m_SndFile.Instruments[nInstr])) return FALSE;
+	if ((nInstr < 1) || (nInstr > m_SndFile.m_nInstruments) || (!m_SndFile.Instruments[nInstr])) return false;
 	if (bMute) m_SndFile.Instruments[nInstr]->dwFlags |= ENV_MUTE;
 	else m_SndFile.Instruments[nInstr]->dwFlags &= ~ENV_MUTE;
-	return TRUE;
+	return true;
 }
 
 
-BOOL CModDoc::SurroundChannel(UINT nChn, BOOL bSurround)
-//------------------------------------------------------
+bool CModDoc::SurroundChannel(CHANNELINDEX nChn, bool bSurround)
+//--------------------------------------------------------------
 {
 	DWORD d = (bSurround) ? CHN_SURROUND : 0;
 	
-	if (nChn >= m_SndFile.m_nChannels) return FALSE;
+	if (nChn >= m_SndFile.m_nChannels) return false;
 	if (!(m_SndFile.m_nType & (MOD_TYPE_IT | MOD_TYPE_MPT))) d = 0;
 	if (d != (m_SndFile.ChnSettings[nChn].dwFlags & CHN_SURROUND))
 	{
@@ -1212,68 +1212,68 @@
 	}
 	if (d)	m_SndFile.Chn[nChn].dwFlags |= CHN_SURROUND;
 	else	m_SndFile.Chn[nChn].dwFlags &= ~CHN_SURROUND;
-	return TRUE;
+	return true;
 }
 
 
-BOOL CModDoc::SetChannelGlobalVolume(UINT nChn, UINT nVolume)
-//-----------------------------------------------------------
+bool CModDoc::SetChannelGlobalVolume(CHANNELINDEX nChn, UINT nVolume)
+//-------------------------------------------------------------------
 {
-	BOOL bOk = FALSE;
-	if ((nChn >= m_SndFile.m_nChannels) || (nVolume > 64)) return FALSE;
+	bool bOk = false;
+	if ((nChn >= m_SndFile.m_nChannels) || (nVolume > 64)) return false;
 	if (m_SndFile.ChnSettings[nChn].nVolume != nVolume)
 	{
 		m_SndFile.ChnSettings[nChn].nVolume = nVolume;
 		if (m_SndFile.m_nType & (MOD_TYPE_IT | MOD_TYPE_MPT)) SetModified();
-		bOk = TRUE;
+		bOk = true;
 	}
 	m_SndFile.Chn[nChn].nGlobalVol = nVolume;
 	return bOk;
 }
 
 
-BOOL CModDoc::SetChannelDefaultPan(UINT nChn, UINT nPan)
-//------------------------------------------------------
+bool CModDoc::SetChannelDefaultPan(CHANNELINDEX nChn, UINT nPan)
+//--------------------------------------------------------------
 {
-	BOOL bOk = FALSE;
-	if ((nChn >= m_SndFile.m_nChannels) || (nPan > 256)) return FALSE;
+	bool bOk = false;
+	if ((nChn >= m_SndFile.m_nChannels) || (nPan > 256)) return false;
 	if (m_SndFile.ChnSettings[nChn].nPan != nPan)
 	{
 		m_SndFile.ChnSettings[nChn].nPan = nPan;
 		if (m_SndFile.m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT | MOD_TYPE_MPT)) SetModified();
-		bOk = TRUE;
+		bOk = true;
 	}
 	m_SndFile.Chn[nChn].nPan = nPan;
 	return bOk;
 }
 
 
-BOOL CModDoc::IsChannelMuted(UINT nChn) const
-//-------------------------------------------
+bool CModDoc::IsChannelMuted(CHANNELINDEX nChn) const
+//---------------------------------------------------
 {
-	if (nChn >= m_SndFile.m_nChannels) return TRUE;
-	return (m_SndFile.ChnSettings[nChn].dwFlags & CHN_MUTE) ? TRUE : FALSE;
+	if (nChn >= m_SndFile.m_nChannels) return true;
+	return (m_SndFile.ChnSettings[nChn].dwFlags & CHN_MUTE) ? true : false;
 }
 
 
-BOOL CModDoc::IsSampleMuted(UINT nSample) const
-//---------------------------------------------
+bool CModDoc::IsSampleMuted(SAMPLEINDEX nSample) const
+//----------------------------------------------------
 {
-	if ((!nSample) || (nSample > m_SndFile.m_nSamples)) return FALSE;
-	return (m_SndFile.Samples[nSample].uFlags & CHN_MUTE) ? TRUE : FALSE;
+	if ((!nSample) || (nSample > m_SndFile.m_nSamples)) return false;
+	return (m_SndFile.Samples[nSample].uFlags & CHN_MUTE) ? true : false;
 }
 
 
-BOOL CModDoc::IsInstrumentMuted(UINT nInstr) const
-//------------------------------------------------
+bool CModDoc::IsInstrumentMuted(INSTRUMENTINDEX nInstr) const
+//-----------------------------------------------------------
 {
-	if ((!nInstr) || (nInstr > m_SndFile.m_nInstruments) || (!m_SndFile.Instruments[nInstr])) return FALSE;
-	return (m_SndFile.Instruments[nInstr]->dwFlags & ENV_MUTE) ? TRUE : FALSE;
+	if ((!nInstr) || (nInstr > m_SndFile.m_nInstruments) || (!m_SndFile.Instruments[nInstr])) return false;
+	return (m_SndFile.Instruments[nInstr]->dwFlags & ENV_MUTE) ? true : false;
 }
 
 
-UINT CModDoc::GetPatternSize(UINT nPat) const
-//-------------------------------------------
+UINT CModDoc::GetPatternSize(PATTERNINDEX nPat) const
+//---------------------------------------------------
 {
 	if ((nPat < m_SndFile.Patterns.Size()) && (m_SndFile.Patterns[nPat])) return m_SndFile.PatternSize[nPat];
 	return 0;

Modified: trunk/OpenMPT/mptrack/Moddoc.h
===================================================================
--- trunk/OpenMPT/mptrack/Moddoc.h	2009-09-17 16:11:47 UTC (rev 368)
+++ trunk/OpenMPT/mptrack/Moddoc.h	2009-09-18 18:48:59 UTC (rev 369)
@@ -150,8 +150,8 @@
 	void PostMessageToAllViews(UINT uMsg, WPARAM wParam=0, LPARAM lParam=0);
 	void SendMessageToActiveViews(UINT uMsg, WPARAM wParam=0, LPARAM lParam=0);
 	UINT GetModType() const { return m_SndFile.m_nType; }
-	BOOL GetNumInstruments() const { return m_SndFile.m_nInstruments; }
-	BOOL GetNumSamples() const { return m_SndFile.m_nSamples; }
+	INSTRUMENTINDEX GetNumInstruments() const { return m_SndFile.m_nInstruments; }
+	SAMPLEINDEX GetNumSamples() const { return m_SndFile.m_nSamples; }
 	BOOL AddToLog(LPCSTR lpszLog);
 	LPCSTR GetLog() const { return m_lpszLog; }
 	BOOL ClearLog();
@@ -211,33 +211,33 @@
 	BOOL NoteOff(UINT note, BOOL bFade=FALSE, UINT nins=-1, UINT nCurrentChn=-1); //rewbs.vstiLive: add params
 
 	BOOL IsNotePlaying(UINT note, UINT nsmp=0, UINT nins=0);
-	BOOL MuteChannel(UINT nChn, BOOL bMute);
-	BOOL MuteSample(UINT nSample, BOOL bMute);
-	BOOL MuteInstrument(UINT nInstr, BOOL bMute);
+	bool MuteChannel(CHANNELINDEX nChn, bool bMute);
+	bool MuteSample(SAMPLEINDEX nSample, bool bMute);
+	bool MuteInstrument(INSTRUMENTINDEX nInstr, bool bMute);
 // -> CODE#0012
 // -> DESC="midi keyboard split"
-	BOOL SoloChannel(UINT nChn, BOOL bSolo);
-	BOOL IsChannelSolo(UINT nChn) const;
+	bool SoloChannel(CHANNELINDEX nChn, bool bSolo);
+	bool IsChannelSolo(CHANNELINDEX nChn) const;
 // -! NEW_FEATURE#0012
-	BOOL SurroundChannel(UINT nChn, BOOL bSurround);
-	BOOL SetChannelGlobalVolume(UINT nChn, UINT nVolume);
-	BOOL SetChannelDefaultPan(UINT nChn, UINT nPan);
-	BOOL IsChannelMuted(UINT nChn) const;
-	BOOL IsSampleMuted(UINT nSample) const;
-	BOOL IsInstrumentMuted(UINT nInstr) const;
+	bool SurroundChannel(CHANNELINDEX nChn, bool bSurround);
+	bool SetChannelGlobalVolume(CHANNELINDEX nChn, UINT nVolume);
+	bool SetChannelDefaultPan(CHANNELINDEX nChn, UINT nPan);
+	bool IsChannelMuted(CHANNELINDEX nChn) const;
+	bool IsSampleMuted(SAMPLEINDEX nSample) const;
+	bool IsInstrumentMuted(INSTRUMENTINDEX nInstr) const;
 // -> CODE#0015
 // -> DESC="channels management dlg"
-	BOOL NoFxChannel(UINT nChn, BOOL bNoFx, BOOL updateMix = TRUE);
-	BOOL IsChannelNoFx(UINT nChn) const;
-	BOOL IsChannelRecord1(UINT channel);
-	BOOL IsChannelRecord2(UINT channel);
-	BYTE IsChannelRecord(UINT channel);
-	void Record1Channel(UINT channel, BOOL select = TRUE);
-	void Record2Channel(UINT channel, BOOL select = TRUE);
-	void ReinitRecordState(BOOL unselect = TRUE);
+	bool NoFxChannel(CHANNELINDEX nChn, bool bNoFx, bool updateMix = true);
+	bool IsChannelNoFx(CHANNELINDEX nChn) const;
+	bool IsChannelRecord1(CHANNELINDEX channel);
+	bool IsChannelRecord2(CHANNELINDEX channel);
+	BYTE IsChannelRecord(CHANNELINDEX channel);
+	void Record1Channel(CHANNELINDEX channel, bool select = true);
+	void Record2Channel(CHANNELINDEX channel, bool select = true);
+	void ReinitRecordState(bool unselect = true);
 // -! NEW_FEATURE#0015
-	UINT GetNumChannels() const { return m_SndFile.m_nChannels; }
-	UINT GetPatternSize(UINT nPat) const;
+	CHANNELINDEX GetNumChannels() const { return m_SndFile.m_nChannels; }
+	UINT GetPatternSize(PATTERNINDEX nPat) const;
 	BOOL AdjustEndOfSample(UINT nSample);
 	BOOL IsChildSample(UINT nIns, UINT nSmp) const;
 	UINT FindSampleParent(UINT nSmp) const;

Modified: trunk/OpenMPT/mptrack/View_tre.cpp
===================================================================
--- trunk/OpenMPT/mptrack/View_tre.cpp	2009-09-17 16:11:47 UTC (rev 368)
+++ trunk/OpenMPT/mptrack/View_tre.cpp	2009-09-18 18:48:59 UTC (rev 369)
@@ -2537,8 +2537,8 @@
 	pModDoc = GetDocumentFromItem(hItem);
 	if (pModDoc)
 	{
-		UINT nSamples = pModDoc->GetNumSamples();
-		UINT nInstruments = pModDoc->GetNumInstruments();
+		SAMPLEINDEX nSamples = pModDoc->GetNumSamples();
+		INSTRUMENTINDEX nInstruments = pModDoc->GetNumInstruments();
 		if ((dwItemType == MODITEM_SAMPLE) && (!nInstruments))
 		{
 			for (UINT i=1; i<=nSamples; i++)
@@ -2568,8 +2568,8 @@
 	pModDoc = GetDocumentFromItem(hItem);
 	if (pModDoc)
 	{
-		UINT nSamples = pModDoc->GetNumSamples();
-		UINT nInstruments = pModDoc->GetNumInstruments();
+		SAMPLEINDEX nSamples = pModDoc->GetNumSamples();
+		INSTRUMENTINDEX nInstruments = pModDoc->GetNumInstruments();
 		if ((dwItemType == MODITEM_SAMPLE) || (dwItemType == MODITEM_INSTRUMENT))
 		{
 			for (UINT i=1; i<=nSamples; i++)

Modified: trunk/OpenMPT/soundlib/Sampleio.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Sampleio.cpp	2009-09-17 16:11:47 UTC (rev 368)
+++ trunk/OpenMPT/soundlib/Sampleio.cpp	2009-09-18 18:48:59 UTC (rev 369)
@@ -1362,9 +1362,9 @@
 			if (!k)
 			{
 				xih.vibtype = Samples[n].nVibType;
-				xih.vibsweep = Samples[n].nVibSweep;
-				xih.vibdepth = Samples[n].nVibDepth;
-				xih.vibrate = Samples[n].nVibRate;
+				xih.vibsweep = min(Samples[n].nVibSweep, 255);
+				xih.vibdepth = min(Samples[n].nVibDepth, 15);
+				xih.vibrate = min(Samples[n].nVibRate, 63);
 			}
 			if (nsamples < 32) smptable[nsamples++] = n;
 			k = nsamples - 1;
@@ -1693,7 +1693,7 @@
 	if (pSmp->nPan > 256) pSmp->nPan = 256;
 	if (pis->dfp & 0x80) pSmp->uFlags |= CHN_PANNING;
 	pSmp->nVibType = autovibit2xm[pis->vit & 7];
-	pSmp->nVibSweep = (pis->vir + 3) / 4;
+	pSmp->nVibSweep = pis->vir;
 	pSmp->nVibDepth = pis->vid;
 	pSmp->nVibRate = pis->vis;
 	UINT flags = (pis->cvt & 1) ? RS_PCM8S : RS_PCM8U;
@@ -1944,9 +1944,9 @@
 		itss.vol = psmp->nVolume >> 2;
 		itss.dfp = psmp->nPan >> 2;
 		itss.vit = autovibxm2it[psmp->nVibType & 7];
-		itss.vir = (psmp->nVibSweep < 64) ? psmp->nVibSweep*4 : 255;
-		itss.vid = psmp->nVibDepth;
-		itss.vis = psmp->nVibRate;
+		itss.vir = min(psmp->nVibSweep, 255);
+		itss.vid = min(psmp->nVibDepth, 32);
+		itss.vis = min(psmp->nVibRate, 64);
 		if (psmp->uFlags & CHN_PANNING) itss.dfp |= 0x80;
 		itss.cvt = 0x01;
 		smpsize = psmp->nLength;

Modified: trunk/OpenMPT/soundlib/Sndfile.h
===================================================================
--- trunk/OpenMPT/soundlib/Sndfile.h	2009-09-17 16:11:47 UTC (rev 368)
+++ trunk/OpenMPT/soundlib/Sndfile.h	2009-09-18 18:48:59 UTC (rev 369)
@@ -40,6 +40,7 @@
 	BYTE nVibSweep;
 	BYTE nVibDepth;
 	BYTE nVibRate;
+	CHAR name[32];
 	CHAR filename[22];
 
 	// Return the size of one (elementary) sample in bytes.
@@ -545,7 +546,10 @@
 
 public:	// for Editing
 	CModDoc* m_pModDoc;
-	UINT m_nType, m_nChannels, m_nSamples, m_nInstruments;
+	UINT m_nType;
+	CHANNELINDEX m_nChannels;
+	SAMPLEINDEX m_nSamples;
+	INSTRUMENTINDEX m_nInstruments;
 	UINT m_nDefaultSpeed, m_nDefaultTempo, m_nDefaultGlobalVolume;
 	DWORD m_dwSongFlags;							// Song flags SONG_XXXX
 	bool m_bIsRendering;


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-09-17 16:11:58

Revision: 368
          http://modplug.svn.sourceforge.net/modplug/?rev=368&view=rev
Author:   saga-games
Date:     2009-09-17 16:11:47 +0000 (Thu, 17 Sep 2009)

Log Message:
-----------
[Fix] Sample Editor: Limit sample vibrato fields properly. Vibrato Sweep ranges from 0 to 255 now.
[Fix] IT Compatibility: Better sample vibrato compatibility. Vibrato Sweep isn't perfect yet, though.
[Mod] Sequence view: Also grey out "Render to wave" menu item if no valid order is selected

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/Ctrl_seq.cpp
    trunk/OpenMPT/mptrack/Ctrl_smp.cpp
    trunk/OpenMPT/soundlib/Load_it.cpp
    trunk/OpenMPT/soundlib/Load_xm.cpp
    trunk/OpenMPT/soundlib/Sndmix.cpp

Modified: trunk/OpenMPT/mptrack/Ctrl_seq.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_seq.cpp	2009-09-16 22:46:46 UTC (rev 367)
+++ trunk/OpenMPT/mptrack/Ctrl_seq.cpp	2009-09-17 16:11:47 UTC (rev 368)
@@ -897,7 +897,7 @@
 		}
 	}
 	AppendMenu(hMenu, MF_SEPARATOR, NULL, "");
-	AppendMenu(hMenu, MF_STRING, ID_ORDERLIST_RENDER, "Render to &Wave");
+	AppendMenu(hMenu, MF_STRING | greyed, ID_ORDERLIST_RENDER, "Render to &Wave");
 
 	ClientToScreen(&pt);
 	::TrackPopupMenu(hMenu, TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt.x, pt.y, 0, m_hWnd, NULL);

Modified: trunk/OpenMPT/mptrack/Ctrl_smp.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_smp.cpp	2009-09-16 22:46:46 UTC (rev 367)
+++ trunk/OpenMPT/mptrack/Ctrl_smp.cpp	2009-09-17 16:11:47 UTC (rev 368)
@@ -228,14 +228,24 @@
 		m_SpinPanning.SetRange(0, 64);
 	}
 	//end rewbs.fix36944
+
+	// Auto vibrato
 	m_ComboAutoVib.AddString("Sine");
 	m_ComboAutoVib.AddString("Square");
 	m_ComboAutoVib.AddString("Ramp Up");
 	m_ComboAutoVib.AddString("Ramp Down");
 	m_ComboAutoVib.AddString("Random");
-	m_SpinVibSweep.SetRange(0, 64);
-	m_SpinVibDepth.SetRange(0, 64);
-	m_SpinVibRate.SetRange(0, 64);
+	m_SpinVibSweep.SetRange(0, 255);
+	if(m_pSndFile->m_nType & MOD_TYPE_XM)
+	{
+		m_SpinVibDepth.SetRange(0, 15);
+		m_SpinVibRate.SetRange(0, 63);
+	} else
+	{
+		m_SpinVibDepth.SetRange(0, 32);
+		m_SpinVibRate.SetRange(0, 64);
+	}
+
 	for (UINT i=BASENOTE_MIN; i<BASENOTE_MAX; i++)
 	{
 		CHAR s[32];

Modified: trunk/OpenMPT/soundlib/Load_it.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_it.cpp	2009-09-16 22:46:46 UTC (rev 367)
+++ trunk/OpenMPT/soundlib/Load_it.cpp	2009-09-17 16:11:47 UTC (rev 368)
@@ -751,7 +751,7 @@
 			pSmp->nVibType = autovibit2xm[pis.vit & 7];
 			pSmp->nVibRate = pis.vis;
 			pSmp->nVibDepth = pis.vid & 0x7F;
-			pSmp->nVibSweep = (pis.vir + 3) / 4;
+			pSmp->nVibSweep = pis.vir;
 			if(pis.length){
 				pSmp->nLength = pis.length;
 				if (pSmp->nLength > MAX_SAMPLE_LENGTH) pSmp->nLength = MAX_SAMPLE_LENGTH;
@@ -1231,7 +1231,7 @@
 			pSmp->nVibType = autovibit2xm[pis->vit & 7];
 			pSmp->nVibRate = pis->vis;
 			pSmp->nVibDepth = pis->vid & 0x7F;
-			pSmp->nVibSweep = (pis->vir + 3) / 4;
+			pSmp->nVibSweep = pis->vir; //(pis->vir + 3) / 4;
 			if ((pis->samplepointer) && (pis->samplepointer < dwMemLength) && (pis->length))
 			{
 				pSmp->nLength = pis->length;
@@ -1719,9 +1719,9 @@
 			itss.vol = psmp->nVolume >> 2;
 			itss.dfp = psmp->nPan >> 2;
 			itss.vit = autovibxm2it[psmp->nVibType & 7];
-			itss.vis = psmp->nVibRate;
-			itss.vid = psmp->nVibDepth;
-			itss.vir = (psmp->nVibSweep < 64) ? psmp->nVibSweep * 4 : 255;
+			itss.vis = min(psmp->nVibRate, 64);
+			itss.vid = min(psmp->nVibDepth, 32);
+			itss.vir = min(psmp->nVibSweep, 255); //(psmp->nVibSweep < 64) ? psmp->nVibSweep * 4 : 255;
 			if (psmp->uFlags & CHN_PANNING) itss.dfp |= 0x80;
 			if ((psmp->pSample) && (psmp->nLength)) itss.cvt = 0x01;
 			UINT flags = RS_PCM8S;
@@ -2351,9 +2351,9 @@
 		itss.vol = psmp->nVolume >> 2;
 		itss.dfp = psmp->nPan >> 2;
 		itss.vit = autovibxm2it[psmp->nVibType & 7];
-		itss.vis = psmp->nVibRate;
-		itss.vid = psmp->nVibDepth;
-		itss.vir = (psmp->nVibSweep < 64) ? psmp->nVibSweep * 4 : 255;
+		itss.vis = min(psmp->nVibRate, 64);
+		itss.vid = min(psmp->nVibDepth, 32);
+		itss.vir = min(psmp->nVibSweep, 255); //(psmp->nVibSweep < 64) ? psmp->nVibSweep * 4 : 255;
 		if (psmp->uFlags & CHN_PANNING) itss.dfp |= 0x80;
 		if ((psmp->pSample) && (psmp->nLength)) itss.cvt = 0x01;
 		UINT flags = RS_PCM8S;
@@ -2987,9 +2987,9 @@
 		itss.vol = psmp->nVolume >> 2;
 		itss.dfp = psmp->nPan >> 2;
 		itss.vit = autovibxm2it[psmp->nVibType & 7];
-		itss.vis = psmp->nVibRate;
-		itss.vid = psmp->nVibDepth;
-		itss.vir = (psmp->nVibSweep < 64) ? psmp->nVibSweep * 4 : 255;
+		itss.vis = min(psmp->nVibRate, 64);
+		itss.vid = min(psmp->nVibDepth, 32);
+		itss.vir = min(psmp->nVibSweep, 255);
 		if (psmp->uFlags & CHN_PANNING) itss.dfp |= 0x80;
 		if ((psmp->pSample) && (psmp->nLength)) itss.cvt = 0x01;
 		UINT flags = RS_PCM8S;

Modified: trunk/OpenMPT/soundlib/Load_xm.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_xm.cpp	2009-09-16 22:46:46 UTC (rev 367)
+++ trunk/OpenMPT/soundlib/Load_xm.cpp	2009-09-17 16:11:47 UTC (rev 368)
@@ -954,9 +954,9 @@
 		{
 			MODSAMPLE *pvib = &Samples[smptable[0]];
 			xmsh.vibtype = pvib->nVibType;
-			xmsh.vibsweep = pvib->nVibSweep;
-			xmsh.vibdepth = pvib->nVibDepth;
-			xmsh.vibrate = pvib->nVibRate;
+			xmsh.vibsweep = min(pvib->nVibSweep, 0xFF);
+			xmsh.vibdepth = min(pvib->nVibDepth, 0x0F);
+			xmsh.vibrate = min(pvib->nVibRate, 0x3F);
 		}
 		WORD samples = xmih.samples;
 		xmih.samples = LittleEndianW(xmih.samples);

Modified: trunk/OpenMPT/soundlib/Sndmix.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Sndmix.cpp	2009-09-16 22:46:46 UTC (rev 367)
+++ trunk/OpenMPT/soundlib/Sndmix.cpp	2009-09-17 16:11:47 UTC (rev 368)
@@ -1448,19 +1448,28 @@
 				//if(IsCompatibleMode(TRK_IMPULSETRACKER)) pChn->nPan = pChn->nRealPan; // TODO
 			}
 			int nPeriodFrac = 0;
-			// Instrument Auto-Vibrato
+			// Sample Auto-Vibrato
 			if ((pChn->pModSample) && (pChn->pModSample->nVibDepth))
 			{
 				MODSAMPLE *pSmp = pChn->pModSample;
 
-				if (pSmp->nVibSweep == 0)
+				if (pSmp->nVibSweep == 0 && !IsCompatibleMode(TRK_IMPULSETRACKER))
 				{
 					pChn->nAutoVibDepth = pSmp->nVibDepth << 8;
 				} else
 				{
 					if (m_nType & (MOD_TYPE_IT | MOD_TYPE_MPT))
 					{
-						pChn->nAutoVibDepth += pSmp->nVibSweep << 3;
+						if(IsCompatibleMode(TRK_IMPULSETRACKER))
+						{
+							// TODO
+							pChn->nAutoVibDepth += pSmp->nVibSweep << 3;
+						} else
+						{
+							/* Note: changed bitshift from 3 to 1 as the variable is not divided by 4 in the IT loader anymore
+							   - so we divide sweep by 4 here. */
+							pChn->nAutoVibDepth += pSmp->nVibSweep << 1;
+						}
 					} else
 					if (!(pChn->dwFlags & CHN_KEYOFF))
 					{


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-09-16 22:46:55

Revision: 367
          http://modplug.svn.sourceforge.net/modplug/?rev=367&view=rev
Author:   saga-games
Date:     2009-09-16 22:46:46 +0000 (Wed, 16 Sep 2009)

Log Message:
-----------
[Fix] XM Loader: Can now load XM Version 1.02 and 1.03. Made XM Loader and Saver a bit more readable.
[Imp] XM Loader: Detect non-mpt modules more reliably
[Mod] Color Presets: Use app directory as default directory in file dialog
[Ref] Made GetZxxType / CreateZxxFromType static so they can be used in CTrackApp for initialization

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/Moddoc.h
    trunk/OpenMPT/mptrack/Moptions.cpp
    trunk/OpenMPT/mptrack/Mptrack.cpp
    trunk/OpenMPT/soundlib/Load_xm.cpp

Modified: trunk/OpenMPT/mptrack/Moddoc.h
===================================================================
--- trunk/OpenMPT/mptrack/Moddoc.h	2009-09-16 19:05:00 UTC (rev 366)
+++ trunk/OpenMPT/mptrack/Moddoc.h	2009-09-16 22:46:46 UTC (rev 367)
@@ -181,8 +181,8 @@
 	int MacroToPlugParam(CString value); //rewbs.xinfo
 	int MacroToMidiCC(CString value);
 	int FindMacroForParam(long param);
-	int GetZxxType(const CHAR (&szMidiZXXExt)[128 * 32]);
-	void CreateZxxFromType(CHAR (&szMidiZXXExt)[128 * 32], int iZxxType);
+	static int GetZxxType(const CHAR (&szMidiZXXExt)[128 * 32]);
+	static void CreateZxxFromType(CHAR (&szMidiZXXExt)[128 * 32], int iZxxType);
 	void SongProperties();
 // operations
 public:

Modified: trunk/OpenMPT/mptrack/Moptions.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Moptions.cpp	2009-09-16 19:05:00 UTC (rev 366)
+++ trunk/OpenMPT/mptrack/Moptions.cpp	2009-09-16 22:46:46 UTC (rev 367)
@@ -562,8 +562,8 @@
 		"OpenMPT Color Schemes|*.mptcolor|"
 		"All Files (*.*)|*.*||",
 		this);
+	dlg.m_ofn.lpstrInitialDir = CMainFrame::m_csExecutableDirectoryPath;
 	if (dlg.DoModal() != IDOK) return;
-
 	
 	TCHAR sFilename[MAX_PATH];
 	strcpy(sFilename, dlg.GetPathName());
@@ -584,6 +584,7 @@
 		OFN_HIDEREADONLY| OFN_ENABLESIZING | OFN_OVERWRITEPROMPT | OFN_PATHMUSTEXIST | OFN_NOREADONLYRETURN,
 		"OpenMPT Color Schemes|*.mptcolor|",
 		this);
+	dlg.m_ofn.lpstrInitialDir = CMainFrame::m_csExecutableDirectoryPath;
 	if (dlg.DoModal() != IDOK) return;
 
 	TCHAR sFilename[MAX_PATH];

Modified: trunk/OpenMPT/mptrack/Mptrack.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Mptrack.cpp	2009-09-16 19:05:00 UTC (rev 366)
+++ trunk/OpenMPT/mptrack/Mptrack.cpp	2009-09-16 22:46:46 UTC (rev 367)
@@ -622,7 +622,7 @@
 	strcpy(&m_MidiCfg.szMidiGlb[MIDIOUT_NOTEOFF*32], "9c n 0");
 	strcpy(&m_MidiCfg.szMidiGlb[MIDIOUT_PROGRAM*32], "Cc p");
 	strcpy(&m_MidiCfg.szMidiSFXExt[0], "F0F000z");
-	for (int iz=0; iz<16; iz++) wsprintf(&m_MidiCfg.szMidiZXXExt[iz*32], "F0F001%02X", iz*8);
+	CModDoc::CreateZxxFromType(m_MidiCfg.szMidiZXXExt, 1);
 
 	#ifdef UPDATECHECKENABLED
 		m_pRequestContext = NULL;

Modified: trunk/OpenMPT/soundlib/Load_xm.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_xm.cpp	2009-09-16 19:05:00 UTC (rev 366)
+++ trunk/OpenMPT/soundlib/Load_xm.cpp	2009-09-16 22:46:46 UTC (rev 367)
@@ -24,16 +24,16 @@
 #pragma pack(1)
 typedef struct tagXMFILEHEADER
 {
-	DWORD size;
-	WORD norder;
-	WORD restartpos;
-	WORD channels;
-	WORD patterns;
-	WORD instruments;
-	WORD flags;
-	WORD speed;
-	WORD tempo;
-	BYTE order[256];
+	WORD xmversion;		// current: 0x0104
+	DWORD size;			// header size
+	WORD orders;		// number of orders
+	WORD restartpos;	// restart position
+	WORD channels;		// number of channels
+	WORD patterns;		// number of patterns
+	WORD instruments;	// number of instruments
+	WORD flags;			// song flags
+	WORD speed;			// default speed
+	WORD tempo;			// default tempo
 } XMFILEHEADER;
 
 
@@ -57,8 +57,13 @@
 	BYTE vtype, ptype;
 	BYTE vibtype, vibsweep, vibdepth, vibrate;
 	WORD volfade;
-	WORD res;
-	BYTE reserved1[20];
+	// midi extensions (not read by MPT)
+	BYTE midienabled;		// 0/1
+	BYTE midichannel;		// 0...15
+	WORD midiprogram;		// 0...127
+	WORD pitchwheelrange;	// 0...36 (halftones)
+	BYTE mutecomputer;		// 0/1
+	BYTE reserved1[15];
 } XMSAMPLEHEADER;
 
 typedef struct tagXMSAMPLESTRUCT
@@ -77,138 +82,80 @@
 #pragma pack()
 
 
-bool CSoundFile::ReadXM(const BYTE *lpStream, DWORD dwMemLength)
-//--------------------------------------------------------------
+// Read .XM patterns
+DWORD ReadXMPatterns(const BYTE *lpStream, DWORD dwMemLength, DWORD dwMemPos, XMFILEHEADER *xmheader, CSoundFile *pSndFile)
+//-------------------------------------------------------------------------------------------------------------------------
 {
-	XMSAMPLEHEADER xmsh;
-	XMSAMPLESTRUCT xmss;
-	DWORD dwMemPos, dwHdrSize;
-	WORD norders=0, restartpos=0, channels=0, patterns=0, instruments=0;
-	WORD xmflags=0;
-	BYTE InstUsed[256];
-// -> CODE#0006
-// -> DESC="misc quantity changes"
-//	BYTE channels_used[MAX_CHANNELS];
-	BYTE channels_used[MAX_BASECHANNELS];
-// -! BEHAVIOUR_CHANGE#0006
+	BYTE patterns_used[256];
 	BYTE pattern_map[256];
-	BYTE samples_used[(MAX_SAMPLES+7)/8];
-	UINT unused_samples;
 
-	bool bMadeWithModPlug = false, bProbablyMadeWithModPlug = false;
-	// set this here already because XMs compressed with BoobieSqueezer will exit the function early
-	SetModFlag(MSF_COMPATIBLE_PLAY, true);
-
-	m_nChannels = 0;
-	if ((!lpStream) || (dwMemLength < 0xAA)) return false; // the smallest XM I know is 174 Bytes
-	if (_strnicmp((LPCSTR)lpStream, "Extended Module", 15)) return false;
-
-	memcpy(m_szNames[0], lpStream + 17, 20);
-	// look for null-terminated song name - that's most likely a tune made with modplug
-	for(int i = 0; i < 20; i++)
-		if(lpStream[17 + i] == 0) bProbablyMadeWithModPlug = true;
-
-	dwHdrSize = LittleEndian(*((DWORD *)(lpStream+60)));
-	norders = LittleEndianW(*((WORD *)(lpStream+64)));
-	if ((!norders) || (norders > MAX_ORDERS)) return false;
-	restartpos = LittleEndianW(*((WORD *)(lpStream+66)));
-	channels = LittleEndianW(*((WORD *)(lpStream+68)));
-// -> CODE#0006
-// -> DESC="misc quantity changes"
-//	if ((!channels) || (channels > 64)) return false;
-	if ((!channels) || (channels > MAX_BASECHANNELS)) return false;
-// -! BEHAVIOUR_CHANGE#0006
-
-	m_nType = MOD_TYPE_XM;
-	m_nMinPeriod = 27;
-	m_nMaxPeriod = 54784;
-	m_nChannels = channels;
-	if (restartpos < norders) m_nRestartPos = restartpos;
-	patterns = CLAMP(LittleEndianW(*((WORD *)(lpStream+70))), 0, 256);
-	instruments = LittleEndianW(*((WORD *)(lpStream+72)));
-	if (instruments >= MAX_INSTRUMENTS) instruments = MAX_INSTRUMENTS-1;
-	m_nInstruments = instruments;
-	m_nSamples = 0;
-	memcpy(&xmflags, lpStream + 74, 2);
-	xmflags = LittleEndianW(xmflags);
-	if (xmflags & 1) m_dwSongFlags |= SONG_LINEARSLIDES;
-	if (xmflags & 0x1000) m_dwSongFlags |= SONG_EXFILTERRANGE;
-	m_nDefaultSpeed = CLAMP(LittleEndianW(*((WORD *)(lpStream+76))), 1, 31);
-// -> CODE#0016
-// -> DESC="default tempo update"
-	m_nDefaultTempo = CLAMP(LittleEndianW(*((WORD *)(lpStream+78))), 32, 512);
-// -! BEHAVIOUR_CHANGE#0016
-	Order.ReadAsByte(lpStream+80, norders, dwMemLength-80);
-	memset(InstUsed, 0, sizeof(InstUsed));
-	if (patterns > MAX_PATTERNS)
+	memset(patterns_used, 0, sizeof(patterns_used));
+	if (xmheader->patterns > MAX_PATTERNS)
 	{
 		UINT i, j;
-		for (i=0; i<norders; i++)
+		for (i = 0; i < xmheader->orders; i++)
 		{
-			if (Order[i] < patterns) InstUsed[Order[i]] = true;
+			if (pSndFile->Order[i] < xmheader->patterns) patterns_used[pSndFile->Order[i]] = true;
 		}
 		j = 0;
-		for (i=0; i<256; i++)
+		for (i = 0; i < 256; i++)
 		{
-			if (InstUsed[i]) pattern_map[i] = j++;
+			if (patterns_used[i]) pattern_map[i] = j++;
 		}
-		for (i=0; i<256; i++)
+		for (i = 0; i < 256; i++)
 		{
-			if (!InstUsed[i])
+			if (!patterns_used[i])
 			{
 				pattern_map[i] = (j < MAX_PATTERNS) ? j : 0xFE;
 				j++;
 			}
 		}
-		for (i=0; i<norders; i++)
+		for (i = 0; i < xmheader->orders; i++)
 		{
-			Order[i] = pattern_map[Order[i]];
+			pSndFile->Order[i] = pattern_map[pSndFile->Order[i]];
 		}
 	} else
 	{
-		for (UINT i=0; i<256; i++) pattern_map[i] = i;
+		for (UINT i = 0; i < 256; i++) pattern_map[i] = i;
 	}
-	memset(InstUsed, 0, sizeof(InstUsed));
-	dwMemPos = dwHdrSize + 60;
-	if (dwMemPos + 8 >= dwMemLength) return true;
+	if (dwMemPos + 8 >= dwMemLength) return dwMemPos;
 	// Reading patterns
-	memset(channels_used, 0, sizeof(channels_used));
-	for (UINT ipat=0; ipat<patterns; ipat++)
+	for (UINT ipat = 0; ipat < xmheader->patterns; ipat++)
 	{
 		UINT ipatmap = pattern_map[ipat];
 		DWORD dwSize = 0;
-		WORD rows=64, packsize=0;
+		WORD rows = 64, packsize = 0;
 		dwSize = LittleEndian(*((DWORD *)(lpStream + dwMemPos)));
-		/*while ((dwMemPos + dwSize >= dwMemLength) || (dwSize & 0xFFFFFF00))
+
+		if(xmheader->xmversion == 0x0102)
 		{
-			if (dwMemPos + 4 >= dwMemLength) break;
-			dwMemPos++;
-			dwSize = LittleEndian(*((DWORD *)(lpStream+dwMemPos)));
-		}*/
-		rows = LittleEndianW(*((WORD *)(lpStream + dwMemPos + 5)));
-// -> CODE#0008
-// -> DESC="#define to set pattern size"
-//		if ((!rows) || (rows > 256)) rows = 64;
+			rows = *((BYTE *)(lpStream + dwMemPos + 5)) + 1;
+			packsize = LittleEndianW(*((WORD *)(lpStream + dwMemPos + 6)));
+		}
+		else
+		{
+			rows = LittleEndianW(*((WORD *)(lpStream + dwMemPos + 5)));
+			packsize = LittleEndianW(*((WORD *)(lpStream + dwMemPos + 7)));
+		}
+
 		if ((!rows) || (rows > MAX_PATTERN_ROWS)) rows = 64;
-// -> BEHAVIOUR_CHANGE#0008
-		packsize = LittleEndianW(*((WORD *)(lpStream + dwMemPos + 7)));
-		if (dwMemPos + dwSize + 4 > dwMemLength) return true;
+		if (dwMemPos + dwSize + 4 > dwMemLength) return 0;
 		dwMemPos += dwSize;
-		if (dwMemPos + packsize > dwMemLength) return true;
+		if (dwMemPos + packsize > dwMemLength) return 0;
 		MODCOMMAND *p;
 		if (ipatmap < MAX_PATTERNS)
 		{
-			if(Patterns.Insert(ipatmap, rows))
+			if(pSndFile->Patterns.Insert(ipatmap, rows))
 				return true;
 
 			if (!packsize) continue;
-			p = Patterns[ipatmap];
+			p = pSndFile->Patterns[ipatmap];
 		} else p = NULL;
 		const BYTE *src = lpStream+dwMemPos;
 		UINT j=0;
 		for (UINT row=0; row<rows; row++)
 		{
-			for (UINT chn=0; chn<m_nChannels; chn++)
+			for (UINT chn=0; chn < xmheader->channels; chn++)
 			{
 				if ((p) && (j < packsize))
 				{
@@ -231,10 +178,8 @@
 					}
 					if (p->note == 97) p->note = 0xFF; else
 					if ((p->note) && (p->note < 97)) p->note += 12;
-					if (p->note) channels_used[chn] = 1;
-					if (p->command | p->param) ConvertModCommand(p);
+					if (p->command | p->param) pSndFile->ConvertModCommand(p);
 					if (p->instr == 0xff) p->instr = 0;
-					if (p->instr) InstUsed[p->instr] = TRUE;
 					if ((vol >= 0x10) && (vol <= 0x50))
 					{
 						p->volcmd = VOLCMD_VOLUME;
@@ -287,17 +232,77 @@
 		}
 		dwMemPos += packsize;
 	}
-	// Wrong offset check
-	while (dwMemPos + 4 < dwMemLength)
+	return dwMemPos;
+}
+
+bool CSoundFile::ReadXM(const BYTE *lpStream, DWORD dwMemLength)
+//--------------------------------------------------------------
+{
+	XMFILEHEADER xmheader;
+	XMSAMPLEHEADER xmsh;
+	XMSAMPLESTRUCT xmss;
+	DWORD dwMemPos;
+	BYTE samples_used[(MAX_SAMPLES + 7) / 8]; // for removing unused samples
+	UINT unused_samples; // dito
+
+	bool bMadeWithModPlug = false, bProbablyMadeWithModPlug = false, bIsFT2 = false;
+	// set this here already because XMs compressed with BoobieSqueezer will exit the function early
+	SetModFlag(MSF_COMPATIBLE_PLAY, true);
+
+	m_nChannels = 0;
+	if ((!lpStream) || (dwMemLength < 0xAA)) return false; // the smallest XM I know is 174 Bytes
+	if (_strnicmp((LPCSTR)lpStream, "Extended Module", 15)) return false;
+
+	memcpy(m_szNames[0], lpStream + 17, 20);
+	// look for null-terminated song name - that's most likely a tune made with modplug
+	for(int i = 0; i < 20; i++)
+		if(lpStream[17 + i] == 0) bProbablyMadeWithModPlug = true;
+
+	// load and convert header
+	memcpy(&xmheader, lpStream + 58, sizeof(XMFILEHEADER));
+	xmheader.size = LittleEndian(xmheader.size);
+	xmheader.xmversion = LittleEndianW(xmheader.xmversion);
+	xmheader.orders = LittleEndianW(xmheader.orders);
+	xmheader.restartpos = LittleEndianW(xmheader.restartpos);
+	xmheader.channels = LittleEndianW(xmheader.channels);
+	xmheader.patterns = LittleEndianW(xmheader.patterns);
+	xmheader.instruments = LittleEndianW(xmheader.instruments);
+	xmheader.flags = LittleEndianW(xmheader.flags);
+	xmheader.speed = LittleEndianW(xmheader.speed);
+	xmheader.tempo = LittleEndianW(xmheader.tempo);
+
+	m_nType = MOD_TYPE_XM;
+	m_nMinPeriod = 27;
+	m_nMaxPeriod = 54784;
+
+	if ((!xmheader.orders) || (xmheader.orders > MAX_ORDERS)) return false;
+	if ((!xmheader.channels) || (xmheader.channels > MAX_BASECHANNELS)) return false;
+	if (xmheader.channels > 32) bMadeWithModPlug = true;
+	m_nRestartPos = xmheader.restartpos;
+	m_nChannels = xmheader.channels;
+	m_nInstruments = min(xmheader.instruments, MAX_INSTRUMENTS - 1);
+	m_nSamples = 0;
+	m_nDefaultSpeed = CLAMP(xmheader.speed, 1, 31);
+	m_nDefaultTempo = CLAMP(xmheader.tempo, 32, 512);
+
+	if(xmheader.flags & 1) m_dwSongFlags |= SONG_LINEARSLIDES;
+	if(xmheader.flags & 0x1000) m_dwSongFlags |= SONG_EXFILTERRANGE;
+
+	Order.ReadAsByte(lpStream + 80, xmheader.orders, dwMemLength - 80);
+
+	dwMemPos = xmheader.size + 60;
+
+	if(xmheader.xmversion >= 0x0104)
 	{
-		DWORD d = LittleEndian(*((DWORD *)(lpStream+dwMemPos)));
-		if (d < 0x300) break;
-		dwMemPos++;
+		if (dwMemPos + 8 >= dwMemLength) return true;
+		dwMemPos = ReadXMPatterns(lpStream, dwMemLength, dwMemPos, &xmheader, this);
+		if(dwMemPos == 0) return true;
 	}
+
 	memset(samples_used, 0, sizeof(samples_used));
 	unused_samples = 0;
 	// Reading instruments
-	for (UINT iIns=1; iIns<=instruments; iIns++)
+	for (INSTRUMENTINDEX iIns = 1; iIns <= m_nInstruments; iIns++)
 	{
 		XMINSTRUMENTHEADER *pih;
 		BYTE flags[32];
@@ -318,9 +323,6 @@
 		Instruments[iIns]->nPluginVolumeHandling = PLUGIN_VOLUMEHANDLING_IGNORE;
 
 		memcpy(Instruments[iIns]->name, pih->name, 22);
-		// look for null-terminated instr name - that's most likely a tune made with modplug
-		for(int i = 0; i < 22; i++)
-			if(pih->name[i] == 0) bProbablyMadeWithModPlug = true;
 
 		if ((nsamples = pih->samples) > 0)
 		{
@@ -344,7 +346,12 @@
 				xmsh.penv[i] = LittleEndianW(xmsh.penv[i]);
 			}
 			xmsh.volfade = LittleEndianW(xmsh.volfade);
-			xmsh.res = LittleEndianW(xmsh.res);
+			xmsh.midiprogram = LittleEndianW(xmsh.midiprogram);
+			xmsh.pitchwheelrange = LittleEndianW(xmsh.pitchwheelrange);
+
+			if(xmsh.midichannel != 0 || xmsh.midienabled != 0 || xmsh.midiprogram != 0 || xmsh.mutecomputer != 0 || xmsh.pitchwheelrange != 0)
+				bIsFT2 = true; // definitely not MPT. (or any other tracker)
+
 			dwMemPos += LittleEndian(pih->size);
 		} else
 		{
@@ -547,9 +554,6 @@
 			pSmp->nVibRate = xmsh.vibrate;
 			memcpy(pSmp->filename, xmss.name, 22);
 			pSmp->filename[21] = 0;
-			// look for null-terminated sample name - that's most likely a tune made with modplug
-			for(int i = 0; i < 22; i++)
-				if(xmss.name[i] == 0) bProbablyMadeWithModPlug = true;
 		}
 #if 0
 		if ((xmsh.reserved2 > nsamples) && (xmsh.reserved2 <= 16))
@@ -557,16 +561,35 @@
 			dwMemPos += (((UINT)xmsh.reserved2) - nsamples) * xmsh.shsize;
 		}
 #endif
-		for (UINT ismpd=0; ismpd<nsamples; ismpd++)
+		if(xmheader.xmversion >= 0x0104)
 		{
-			if ((samplemap[ismpd]) && (samplesize[ismpd]) && (dwMemPos < dwMemLength))
+			for (UINT ismpd = 0; ismpd < nsamples; ismpd++)
 			{
-				ReadSample(&Samples[samplemap[ismpd]], flags[ismpd], (LPSTR)(lpStream + dwMemPos), dwMemLength - dwMemPos);
+				if ((samplemap[ismpd]) && (samplesize[ismpd]) && (dwMemPos < dwMemLength))
+				{
+					ReadSample(&Samples[samplemap[ismpd]], flags[ismpd], (LPSTR)(lpStream + dwMemPos), dwMemLength - dwMemPos);
+				}
+				dwMemPos += samplesize[ismpd];
+				if (dwMemPos >= dwMemLength) break;
 			}
-			dwMemPos += samplesize[ismpd];
+		}
+	}
+
+	if(xmheader.xmversion < 0x0104)
+	{
+		// Load Patterns and Samples (Version 1.02 and 1.03)
+		if (dwMemPos + 8 >= dwMemLength) return true;
+		dwMemPos = ReadXMPatterns(lpStream, dwMemLength, dwMemPos, &xmheader, this);
+		if(dwMemPos == 0) return true;
+
+		for(SAMPLEINDEX iSmp = 1; iSmp <= m_nSamples; iSmp++)
+		{
+			ReadSample(&Samples[iSmp], (Samples[iSmp].uFlags & CHN_16BIT) ? RS_PCM16D : RS_PCM8D, (LPSTR)(lpStream + dwMemPos), dwMemLength - dwMemPos);
+			dwMemPos += Samples[iSmp].GetSampleSizeInBytes();
 			if (dwMemPos >= dwMemLength) break;
 		}
 	}
+
 	// Read song comments: "TEXT"
 	if ((dwMemPos + 8 < dwMemLength) && (LittleEndian(*((DWORD *)(lpStream+dwMemPos))) == 0x74786574))
 	{
@@ -640,7 +663,7 @@
 
 	// Check various things to find out whether this has been made with MPT.
 	// Null chars in names -> most likely made with MPT, which disguises as FT2
-	if (!memcmp((LPCSTR)lpStream + 0x26, "FastTracker v2.00   ", 20) && bProbablyMadeWithModPlug) bMadeWithModPlug = true;
+	if (!memcmp((LPCSTR)lpStream + 0x26, "FastTracker v2.00   ", 20) && bProbablyMadeWithModPlug && !bIsFT2) bMadeWithModPlug = true;
 	if (!memcmp((LPCSTR)lpStream + 0x26, "FastTracker v 2.00  ", 20))
 	{
 		// Early MPT 1.0 alpha/beta versions
@@ -701,7 +724,7 @@
 
 	//BYTE s[64*64*5];
 	vector<BYTE> s(64*64*5, 0);
-	XMFILEHEADER header;
+	XMFILEHEADER xmheader;
 	XMINSTRUMENTHEADER xmih;
 	XMSAMPLEHEADER xmsh;
 	XMSAMPLESTRUCT xmss;
@@ -718,21 +741,22 @@
 	fwrite(m_szNames[0], 20, 1, f);
 	s[0] = 0x1A;
 	lstrcpy((LPSTR)&s[1], (nPacking) ? "MOD Plugin packed   " : "OpenMPT " MPT_VERSION_STR "  ");
-	s[21] = 0x04; // Version number
-	s[22] = 0x01; // XM Format v1.04
-	fwrite(&s[0], 23, 1, f);
+	fwrite(&s[0], 21, 1, f);
+
 	// Writing song header
-	memset(&header, 0, sizeof(header));
-	header.size = sizeof(XMFILEHEADER);
-	header.norder = 0;
-	header.restartpos = m_nRestartPos;
+	memset(&xmheader, 0, sizeof(xmheader));
+	xmheader.xmversion = LittleEndianW(0x0104); // XM Format v1.04
+	xmheader.size = sizeof(XMFILEHEADER) - 2; // minus the version field
+	xmheader.restartpos = LittleEndianW(m_nRestartPos);
 
-	header.channels = (m_nChannels + 1) & 0xFFFE; // avoid odd channel count for FT2 compatibility
+	xmheader.channels = (m_nChannels + 1) & 0xFFFE; // avoid odd channel count for FT2 compatibility
 	if(m_nChannels & 1) bAddChannel = true;
-	if(bCompatibilityExport && header.channels > 32)
-		header.channels = 32;
+	if(bCompatibilityExport && xmheader.channels > 32)
+		xmheader.channels = 32;
+	if(xmheader.channels > MAX_BASECHANNELS) xmheader.channels = MAX_BASECHANNELS;
+	xmheader.channels = LittleEndianW(xmheader.channels);
 
-	header.patterns = 0;
+	xmheader.patterns = 0;
   /*for (i=0; i<MAX_ORDERS; i++) {
 		header.norder++;
 		if ((Order[i] >= header.patterns) && (Order[i] < MAX_PATTERNS)) header.patterns = Order[i]+1;
@@ -740,33 +764,37 @@
 	if(Order.GetLength() < MAX_ORDERS)
 		Order.resize(MAX_ORDERS);
 
-	for (i=MAX_ORDERS-1; i>=0; i--) { // walk backwards over orderlist
-		if ((Order[i]!=0xFF) && (header.norder==0)) {
-			header.norder=i+1;	//find last used order
+	WORD nOrders = Order.GetLengthTailTrimmed(), nPatterns = 0;
+	xmheader.orders = LittleEndianW(nOrders);
+	xmheader.size = LittleEndian(xmheader.size + nOrders);
+
+	for (i = 0; i < nOrders; i++) { // walk over orderlist and find last used pattern
+		if((Order[i] >= nPatterns) && (Order[i] < MAX_PATTERNS)) {
+			nPatterns = Order[i] + 1;
 		}
-		if ((Order[i] >= header.patterns) && (Order[i] < MAX_PATTERNS)) {
-			header.patterns = Order[i]+1;	//find last pattern
-		}
 	}
+	xmheader.patterns = LittleEndianW(nPatterns);
 
-	header.instruments = m_nInstruments;
-	if (!header.instruments) header.instruments = m_nSamples;
-	header.flags = (m_dwSongFlags & SONG_LINEARSLIDES) ? 0x01 : 0x00;
-	if (m_dwSongFlags & SONG_EXFILTERRANGE) header.flags |= 0x1000;
+	if(m_nInstruments > 0)
+		xmheader.instruments = LittleEndianW(m_nInstruments);
+	else
+		xmheader.instruments = LittleEndianW(m_nSamples);
+
+	xmheader.flags = (m_dwSongFlags & SONG_LINEARSLIDES) ? 0x01 : 0x00;
+	if (m_dwSongFlags & SONG_EXFILTERRANGE) xmheader.flags |= 0x1000;
+	xmheader.flags = LittleEndianW(xmheader.flags);
+
 	if(bCompatibilityExport)
-	{	
-		header.tempo = CLAMP(m_nDefaultTempo, 32, 255);
-	}
+		xmheader.tempo = LittleEndianW(CLAMP(m_nDefaultTempo, 32, 255));
 	else
-	{
-		header.tempo = m_nDefaultTempo;
-	}
-	header.speed = CLAMP(m_nDefaultSpeed, 1, 31);
-	Order.WriteToByteArray(header.order, header.norder, 256);
+		xmheader.tempo = LittleEndianW(CLAMP(m_nDefaultTempo, 32, 512));
+	xmheader.speed = LittleEndianW(CLAMP(m_nDefaultSpeed, 1, 31));
 
-	fwrite(&header, 1, sizeof(header), f);
+	fwrite(&xmheader, 1, sizeof(xmheader), f);
+	Order.WriteAsByte(f, nOrders);
+
 	// Writing patterns
-	for (i=0; i<header.patterns; i++) if (Patterns[i])
+	for (i = 0; i < nPatterns; i++) if (Patterns[i])
 	{
 		MODCOMMAND *p = Patterns[i];
 		UINT len = 0;
@@ -851,7 +879,7 @@
 		fwrite(xmph, 1, 9, f);
 	}
 	// Writing instruments
-	for (i=1; i<=header.instruments; i++)
+	for (i = 1; i <= xmheader.instruments; i++)
 	{
 		MODSAMPLE *pSmp;
 		WORD smptable[32];
@@ -860,7 +888,7 @@
 		memset(&smptable, 0, sizeof(smptable));
 		memset(&xmih, 0, sizeof(xmih));
 		memset(&xmsh, 0, sizeof(xmsh));
-		xmih.size = sizeof(xmih) + sizeof(xmsh);
+		xmih.size = LittleEndian(sizeof(xmih) + sizeof(xmsh));
 		memcpy(xmih.name, m_szNames[i], 22);
 		xmih.type = 0;
 		xmih.samples = 0;
@@ -871,17 +899,17 @@
 			{
 				memcpy(xmih.name, pIns->name, 22);
 				xmih.type = pIns->nMidiProgram;
-				xmsh.volfade = min(pIns->nFadeOut, 0xFFF); // FFF is maximum in FT2
+				xmsh.volfade = LittleEndianW(min(pIns->nFadeOut, 0xFFF)); // FFF is maximum in FT2
 				xmsh.vnum = (BYTE)pIns->VolEnv.nNodes;
 				xmsh.pnum = (BYTE)pIns->PanEnv.nNodes;
 				if (xmsh.vnum > 12) xmsh.vnum = 12;
 				if (xmsh.pnum > 12) xmsh.pnum = 12;
 				for (UINT ienv=0; ienv<12; ienv++)
 				{
-					xmsh.venv[ienv*2] = pIns->VolEnv.Ticks[ienv];
-					xmsh.venv[ienv*2+1] = pIns->VolEnv.Values[ienv];
-					xmsh.penv[ienv*2] = pIns->PanEnv.Ticks[ienv];
-					xmsh.penv[ienv*2+1] = pIns->PanEnv.Values[ienv];
+					xmsh.venv[ienv*2] = LittleEndianW(pIns->VolEnv.Ticks[ienv]);
+					xmsh.venv[ienv*2+1] = LittleEndianW(pIns->VolEnv.Values[ienv]);
+					xmsh.penv[ienv*2] = LittleEndianW(pIns->PanEnv.Ticks[ienv]);
+					xmsh.penv[ienv*2+1] = LittleEndianW(pIns->PanEnv.Values[ienv]);
 				}
 				if (pIns->dwFlags & ENV_VOLUME) xmsh.vtype |= 1;
 				if (pIns->dwFlags & ENV_VOLSUSTAIN) xmsh.vtype |= 2;
@@ -914,15 +942,13 @@
 					if (xmih.samples >= 32) break;
 					xmsh.snum[j] = k;	//record sample table offset in instrument's note map
 				}
-//				xmsh.reserved2 = xmih.samples;
 			}
 		} else
 		{
 			xmih.samples = 1;
-//			xmsh.reserved2 = 1;
 			smptable[0] = i;
 		}
-		xmsh.shsize = (xmih.samples) ? 40 : 0;
+		xmsh.shsize = LittleEndianW((xmih.samples) ? 40 : 0);
 		fwrite(&xmih, 1, sizeof(xmih), f);
 		if (smptable[0])
 		{
@@ -932,9 +958,11 @@
 			xmsh.vibdepth = pvib->nVibDepth;
 			xmsh.vibrate = pvib->nVibRate;
 		}
-		fwrite(&xmsh, 1, xmih.size - sizeof(xmih), f);
+		WORD samples = xmih.samples;
+		xmih.samples = LittleEndianW(xmih.samples);
+		fwrite(&xmsh, 1, sizeof(xmsh), f);
 		if (!xmih.samples) continue;
-		for (UINT ins=0; ins<xmih.samples; ins++)
+		for (UINT ins = 0; ins < samples; ins++)
 		{
 			memset(&xmss, 0, sizeof(xmss));
 			if (smptable[ins]) memcpy(xmss.name, m_szNames[smptable[ins]], 22);
@@ -979,6 +1007,9 @@
 			xmss.pan = 255;
 			if (pSmp->nPan < 256) xmss.pan = (BYTE)pSmp->nPan;
 			xmss.relnote = (signed char)pSmp->RelativeTone;
+			xmss.samplen = LittleEndianW(xmss.samplen);
+			xmss.loopstart = LittleEndianW(xmss.loopstart);
+			xmss.looplen = LittleEndianW(xmss.looplen);
 			fwrite(&xmss, 1, xmsh.shsize, f);
 		}
 		for (UINT ismpd=0; ismpd<xmih.samples; ismpd++)
@@ -1050,7 +1081,7 @@
 
 		//Save hacked-on extra info
 		SaveMixPlugins(f);
-		SaveExtendedInstrumentProperties(Instruments, header.instruments, f);
+		SaveExtendedInstrumentProperties(Instruments, xmheader.instruments, f);
 		SaveExtendedSongProperties(f);
 	}
 


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <rel...@us...> - 2009-09-16 19:05:12

Revision: 366
          http://modplug.svn.sourceforge.net/modplug/?rev=366&view=rev
Author:   relabsoluness
Date:     2009-09-16 19:05:00 +0000 (Wed, 16 Sep 2009)

Log Message:
-----------
[New] MPTM: Can now have multiple sequences in a module (access from orderlist context menu).
[Fix] MPTM save/load: Loading extensions was broken in the case of not having any instruments.
[Ref] Internal: minor changes and cleanup.

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/Ctrl_pat.cpp
    trunk/OpenMPT/mptrack/Ctrl_pat.h
    trunk/OpenMPT/mptrack/Ctrl_seq.cpp
    trunk/OpenMPT/mptrack/Draw_pat.cpp
    trunk/OpenMPT/mptrack/Moddoc.cpp
    trunk/OpenMPT/mptrack/Modedit.cpp
    trunk/OpenMPT/mptrack/View_pat.cpp
    trunk/OpenMPT/mptrack/View_tre.cpp
    trunk/OpenMPT/mptrack/View_tre.h
    trunk/OpenMPT/mptrack/mptrack.rc
    trunk/OpenMPT/mptrack/resource.h
    trunk/OpenMPT/mptrack/serialization_utils.cpp
    trunk/OpenMPT/mptrack/serialization_utils.h
    trunk/OpenMPT/soundlib/Load_it.cpp
    trunk/OpenMPT/soundlib/Load_psm.cpp
    trunk/OpenMPT/soundlib/Load_xm.cpp
    trunk/OpenMPT/soundlib/ModSequence.cpp
    trunk/OpenMPT/soundlib/ModSequence.h
    trunk/OpenMPT/soundlib/Snd_defs.h
    trunk/OpenMPT/soundlib/Sndfile.cpp
    trunk/OpenMPT/soundlib/Sndfile.h

Modified: trunk/OpenMPT/mptrack/Ctrl_pat.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_pat.cpp	2009-09-15 22:10:35 UTC (rev 365)
+++ trunk/OpenMPT/mptrack/Ctrl_pat.cpp	2009-09-16 19:05:00 UTC (rev 366)
@@ -66,6 +66,7 @@
 	ON_COMMAND(IDC_PATINSTROPLUGGUI2,		ToggleSplitPluginEditor) //rewbs.instroVST
 	ON_EN_CHANGE(IDC_EDIT_SPACING,			OnSpacingChanged)
 	ON_EN_CHANGE(IDC_EDIT_PATTERNNAME,		OnPatternNameChanged)
+	ON_EN_CHANGE(IDC_EDIT_SEQUENCE_NAME,	OnSequenceNameChanged)
 	ON_EN_KILLFOCUS(IDC_EDIT_ORDERLIST_MARGINS, OnOrderListMarginsChanged)
 	ON_UPDATE_COMMAND_UI(IDC_PATTERN_RECORD,OnUpdateRecord)
 	ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipText)
@@ -278,6 +279,9 @@
 	m_OrderList.UpdateView(dwHintMask, pObj);
 	if (!m_pSndFile) return;
 
+	if (dwHintMask & HINT_MODSEQUENCE)
+		SetDlgItemText(IDC_EDIT_SEQUENCE_NAME, m_pSndFile->Order.m_sName);
+
 	//rewbs.instroVST
 	if (dwHintMask & (HINT_MIXPLUGINS|HINT_MODTYPE))
 	{
@@ -289,6 +293,10 @@
             ::EnableWindow(::GetDlgItem(m_hWnd, IDC_PATINSTROPLUGGUI2), true);
 		else
 			::EnableWindow(::GetDlgItem(m_hWnd, IDC_PATINSTROPLUGGUI2), false);
+
+		// Show/hide multisequence controls according the current modtype.
+		GetDlgItem(IDC_STATIC_SEQUENCE_NAME)->ShowWindow( (m_pSndFile->GetType() == MOD_TYPE_MPT) ? SW_SHOW : SW_HIDE);
+		GetDlgItem(IDC_EDIT_SEQUENCE_NAME)->ShowWindow( (m_pSndFile->GetType() == MOD_TYPE_MPT) ? SW_SHOW : SW_HIDE);
 	}
 	//end rewbs.instroVST
 	if (dwHintMask & HINT_MPTOPTIONS)
@@ -611,7 +619,7 @@
 		
 		//Restore all save pattern state, except pattern number which we might have just set.
 		PATTERNVIEWSTATE* patternViewState = pFrame->GetPatternViewState();
-		patternViewState->nPattern = SendViewMessage(VIEWMSG_GETCURRENTPATTERN);
+		patternViewState->nPattern = static_cast<PATTERNINDEX>(SendViewMessage(VIEWMSG_GETCURRENTPATTERN));
 		if (pFrame) SendViewMessage(VIEWMSG_LOADSTATE, (LPARAM)patternViewState);
 		
 		SwitchToView();
@@ -919,7 +927,7 @@
 					nNewPat = pReplaceIndex[nCurPat]; // take care of patterns that have been duplicated before
 				else
 					nNewPat= pSndFile->Order[selection.nOrdLo + i];
-				if (selection.nOrdLo + i + nInsertCount + 1 < pSndFile->Order.GetCount())
+				if (selection.nOrdLo + i + nInsertCount + 1 < pSndFile->Order.GetLength())
 					pSndFile->Order[selection.nOrdLo + i + nInsertCount + 1] = nNewPat;
 			}
 		}
@@ -927,7 +935,7 @@
 		{
 			m_OrderList.InvalidateRect(NULL, FALSE);
 			m_OrderList.SetCurSel(nInsertWhere);
-			SetCurrentPattern(pSndFile->Order[min(nInsertWhere, pSndFile->Order.GetCount()-1)]);
+			SetCurrentPattern(pSndFile->Order[min(nInsertWhere, pSndFile->Order.GetLastIndex())]);
 			m_pModDoc->SetModified();
 			m_pModDoc->UpdateAllViews(NULL, HINT_MODSEQUENCE|HINT_PATNAMES, this);
 			if(selection.nOrdHi != selection.nOrdLo) m_OrderList.m_nScrollPos2nd = nInsertWhere + nInsertCount;
@@ -1140,6 +1148,22 @@
 }
 
 
+void CCtrlPatterns::OnSequenceNameChanged()
+//-----------------------------------------
+{
+	if (m_pSndFile)
+	{
+		CString str;
+		GetDlgItemText(IDC_EDIT_SEQUENCE_NAME, str);
+		if (str != m_pSndFile->Order.m_sName)
+		{
+			m_pSndFile->Order.m_sName = str;
+			m_pModDoc->SetModified();
+		}
+	}
+}
+
+
 void CCtrlPatterns::OnSetupZxxMacros()
 //------------------------------------
 {

Modified: trunk/OpenMPT/mptrack/Ctrl_pat.h
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_pat.h	2009-09-15 22:10:35 UTC (rev 365)
+++ trunk/OpenMPT/mptrack/Ctrl_pat.h	2009-09-16 19:05:00 UTC (rev 366)
@@ -47,13 +47,15 @@
 	// make the current selection the secondary selection (used for keyboard orderlist navigation)
 	inline void SetCurSelTo2ndSel()
 		{if(m_bShift && m_nScrollPos2nd == ORDERINDEX_INVALID) m_nScrollPos2nd = m_nScrollPos; else if(!m_bShift && m_nScrollPos2nd != ORDERINDEX_INVALID) m_nScrollPos2nd = ORDERINDEX_INVALID;};
-	bool SetCurSel(ORDERINDEX sel, bool bEdit = true, bool bShiftClick = false);
+	bool SetCurSel(ORDERINDEX sel, bool bEdit = true, bool bShiftClick = false, bool bIgnoreCurSel = false);
 	BOOL ProcessKeyDown(UINT nChar);
 	BOOL ProcessChar(UINT nChar);
 	BOOL UpdateScrollInfo();
 	void UpdateInfoText();
 	int GetFontWidth();
 
+	ORDERINDEX GetOrderFromPoint(const CRect& rect, const CPoint& pt) const;
+
 	// Sets target margin value and returns the effective margin value.
 	BYTE SetMargins(int);
 
@@ -113,6 +115,7 @@
 	afx_msg void OnPatternPaste();
 	afx_msg LRESULT OnDragonDropping(WPARAM bDoDrop, LPARAM lParam);
 	afx_msg LRESULT OnHelpHitTest(WPARAM, LPARAM lParam);
+	afx_msg void OnSelectSequence(UINT nid);
 	//}}AFX_MSG
 	DECLARE_MESSAGE_MAP()
 };
@@ -218,6 +221,7 @@
 	afx_msg void OnNextInstrument();
 	afx_msg void OnSpacingChanged();
 	afx_msg void OnPatternNameChanged();
+	afx_msg void OnSequenceNameChanged();
 	afx_msg void OnOrderListMarginsChanged();
 	afx_msg void OnSetupZxxMacros();
 	afx_msg void OnChordEditor();

Modified: trunk/OpenMPT/mptrack/Ctrl_seq.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_seq.cpp	2009-09-15 22:10:35 UTC (rev 365)
+++ trunk/OpenMPT/mptrack/Ctrl_seq.cpp	2009-09-16 19:05:00 UTC (rev 366)
@@ -54,6 +54,7 @@
 	ON_COMMAND(ID_ORDERLIST_COPY,		OnDuplicatePattern)
 	ON_COMMAND(ID_PATTERNCOPY,			OnPatternCopy)
 	ON_COMMAND(ID_PATTERNPASTE,			OnPatternPaste)
+	ON_COMMAND_RANGE(ID_SEQUENCE_ITEM, ID_SEQUENCE_ITEM + MAX_SEQUENCES + 1, OnSelectSequence)
 	ON_MESSAGE(WM_MOD_DRAGONDROPPING,	OnDragonDropping)
 	ON_MESSAGE(WM_HELPHITTEST,			OnHelpHitTest)
 	//}}AFX_MSG_MAP
@@ -87,6 +88,13 @@
 }
 
 
+ORDERINDEX COrderList::GetOrderFromPoint(const CRect& rect, const CPoint& pt) const
+//---------------------------------------------------------------------------------
+{
+	return static_cast<ORDERINDEX>(m_nXScroll + (pt.x - rect.left) / m_cxFont);
+}
+
+
 BOOL COrderList::Init(const CRect &rect, CCtrlPatterns *pParent, CModDoc *pModDoc, HFONT hFont)
 //---------------------------------------------------------------------------------------------
 {
@@ -216,18 +224,20 @@
 		else
 			result.nOrdHi = m_nScrollPos2nd;
 	}
+	LimitMax(result.nOrdLo, m_pModDoc->GetSoundFile()->Order.GetLastIndex());
+	LimitMax(result.nOrdHi, m_pModDoc->GetSoundFile()->Order.GetLastIndex());
 	return result;
 }
 
-bool COrderList::SetCurSel(ORDERINDEX sel, bool bEdit, bool bShiftClick)
-//----------------------------------------------------------------------
+bool COrderList::SetCurSel(ORDERINDEX sel, bool bEdit, bool bShiftClick, bool bIgnoreCurSel)
+//------------------------------------------------------------------------------------------
 {
 	CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
 	CSoundFile *pSndFile = m_pModDoc->GetSoundFile();
 	ORDERINDEX *nOrder = (bShiftClick) ? &m_nScrollPos2nd : &m_nScrollPos;
 
-	if ((sel < 0) || (sel >= int(pSndFile->Order.size())) || (!m_pParent) || (!pMainFrm)) return false;
-	if (sel == *nOrder) return true;
+	if ((sel < 0) || (sel >= pSndFile->Order.GetLength()) || (!m_pParent) || (!pMainFrm)) return false;
+	if (!bIgnoreCurSel && sel == *nOrder) return true;
 	const BYTE nShownLength = GetLength();
 	InvalidateSelection();
 	*nOrder = sel;
@@ -281,7 +291,7 @@
 				END_CRITICAL();
 			}
 			m_pParent->SetCurrentPattern(n);
-			m_pModDoc->SetElapsedTime(static_cast<ORDERINDEX>(m_nScrollPos), 0);
+			m_pModDoc->SetElapsedTime(m_nScrollPos, 0);
 		}
 	}
 	UpdateInfoText();
@@ -294,7 +304,7 @@
 //----------------------------------------
 {
 	CSoundFile* pSndFile = m_pModDoc ? m_pModDoc->GetSoundFile() : NULL;
-	if ((pSndFile) && (m_nScrollPos < pSndFile->Patterns.Size()))
+	if ((pSndFile) && (m_nScrollPos < pSndFile->Order.GetLength()))
 	{
 		return pSndFile->Order[m_nScrollPos];
 	}
@@ -316,11 +326,11 @@
 		if (m_pModDoc)
 		{
 			CSoundFile *pSndFile = m_pModDoc->GetSoundFile();
-			ORDERINDEX i = 0;
-			const int nSeqLength = pSndFile->Order.size();
-			for (i=0; i+1 < nSeqLength; i++) if (pSndFile->Order[i+1] == pSndFile->Order.GetInvalidPatIndex()) break;
+			ORDERINDEX nLast = pSndFile->Order.GetLengthFirstEmpty();
+			if (nLast)
+				nLast--;
 			SetCurSelTo2ndSel();
-			SetCurSel(i);
+			SetCurSel(nLast);
 		}
 		break;
 	case VK_DELETE:	OnDeleteOrder(); break;
@@ -484,7 +494,7 @@
 			m_nScrollPos, pSndFile->GetNumPatterns(), m_nScrollPos, pSndFile->GetNumPatterns());
 		}
 		
-		if (m_nScrollPos < int(pSndFile->Order.size()))
+		if (m_nScrollPos < pSndFile->Order.GetLength())
 		{
 			UINT nPat = pSndFile->Order[m_nScrollPos];
 			if ((nPat < pSndFile->Patterns.Size()) && (nPat < pSndFile->m_nPatternNames))
@@ -535,7 +545,7 @@
 		while (rect.left < rcClient.right)
 		{
 			bool bHighLight = ((bFocus) && (nIndex >= selection.nOrdLo && nIndex <= selection.nOrdHi)) ? true : false;
-			ORDERINDEX nOrder = ((nIndex >= 0) && (nIndex < int(pSndFile->Order.size()))) ? pSndFile->Order[nIndex] : -1;
+			const PATTERNINDEX nPat = ((nIndex >= 0) && (nIndex < pSndFile->Order.GetLength())) ? pSndFile->Order[nIndex] : PATTERNINDEX_INVALID;
 			if ((rect.right = rect.left + m_cxFont) > rcClient.right) rect.right = rcClient.right;
 			rect.right--;
 			if (bHighLight) {
@@ -546,7 +556,7 @@
 			
 			
 			//Drawing the shown pattern-indicator or drag position.
-			if (nIndex == ((m_bDragging) ? (int)m_nDropPos : m_nScrollPos))
+			if (nIndex == ((m_bDragging) ? m_nDropPos : m_nScrollPos))
 			{
 				rect.InflateRect(-1, -1);
 				dc.DrawFocusRect(&rect);
@@ -555,7 +565,7 @@
 			MoveToEx(dc.m_hDC, rect.right, rect.top, NULL);
 			LineTo(dc.m_hDC, rect.right, rect.bottom);
 			//Drawing the 'ctrl-transition' indicator
-			if (nIndex == (int)pSndFile->m_nSeqOverride-1)
+			if (nIndex == pSndFile->m_nSeqOverride-1)
 			{
 				MoveToEx(dc.m_hDC, rect.left+4, rect.bottom-4, NULL);
 				LineTo(dc.m_hDC, rect.right-4, rect.bottom-4);
@@ -564,21 +574,18 @@
             CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
 
             //Drawing 'playing'-indicator.
-			if(nIndex == (int)pSndFile->GetCurrentOrder() && pMainFrm->IsPlaying() )
+			if(nIndex == pSndFile->GetCurrentOrder() && pMainFrm->IsPlaying() )
 			{
 				MoveToEx(dc.m_hDC, rect.left+4, rect.top+2, NULL);
 				LineTo(dc.m_hDC, rect.right-4, rect.top+2);
 			}
 			s[0] = 0;
-			if ((nOrder >= 0) && (rect.left + m_cxFont - 4 <= rcClient.right))
+			if ((nIndex < pSndFile->Order.GetLength()) && (rect.left + m_cxFont - 4 <= rcClient.right))
 			{
-				if (nIndex < pSndFile->Order.GetCount())
-				{
-					if (nOrder == pSndFile->Order.GetInvalidPatIndex()) strcpy(s, "---");
-					else if (nOrder == pSndFile->Order.GetIgnoreIndex()) strcpy(s, "+++");
-					else if (nOrder < pSndFile->Patterns.Size()) wsprintf(s, "%d", nOrder);
-					else strcpy(s, "???");
-				}
+				if (nPat == pSndFile->Order.GetInvalidPatIndex()) strcpy(s, "---");
+				else if (nPat == pSndFile->Order.GetIgnoreIndex()) strcpy(s, "+++");
+				else if (nPat < pSndFile->Patterns.Size()) wsprintf(s, "%u", nPat);
+				else strcpy(s, "???");
 			}
 			dc.SetTextColor((bHighLight) ? colorTextSel : colorText);
 			dc.DrawText(s, -1, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
@@ -626,8 +633,8 @@
 			if (m_pModDoc)
 			{
 				CSoundFile *pSndFile = m_pModDoc->GetSoundFile();
-				ORDERINDEX nOrder = m_nXScroll + (pt.x - rect.left) / m_cxFont;
-				if ((nOrder >= 0) && (nOrder < int(pSndFile->Order.size())))
+				ORDERINDEX nOrder = GetOrderFromPoint(rect, pt);
+				if ((nOrder >= 0) && (nOrder < pSndFile->Order.GetLength()))
 				{
 					if (pSndFile->m_nSeqOverride == static_cast<UINT>(nOrder)+1) {
 						pSndFile->m_nSeqOverride=0;
@@ -642,7 +649,7 @@
 			// mark pattern (+skip to)
 			const int oldXScroll = m_nXScroll;
 
-			ORDERINDEX nOrder = m_nXScroll + (pt.x - rect.left) / m_cxFont;
+			ORDERINDEX nOrder = GetOrderFromPoint(rect, pt);
 			ORD_SELECTION selection = GetCurSel(false);					
 
 			// check if cursor is in selection - if it is, only react on MouseUp as the user might want to drag those orders
@@ -678,7 +685,7 @@
 		ReleaseCapture();
 		if (rect.PtInRect(pt))
 		{
-			int n = m_nXScroll + (pt.x - rect.left) / m_cxFont;
+			ORDERINDEX n = GetOrderFromPoint(rect, pt);
 			if ((n >= 0) && (n == m_nDropPos) && (m_pModDoc))
 			{
 				// drag multiple orders (not quite as easy...)
@@ -719,7 +726,7 @@
 			}
 			else
 			{
-				ORDERINDEX nOrder = m_nXScroll + (pt.x - rect.left) / m_cxFont;
+				ORDERINDEX nOrder = GetOrderFromPoint(rect, pt);
 				ORD_SELECTION selection = GetCurSel(false);
 
 				// this should actually have equal signs but that breaks multiselect: nOrder >= selection.nOrdLo && nOrder <= section.nOrdHi
@@ -728,7 +735,7 @@
 					// Remove selection if we didn't drag anything but multiselect was active
 					m_nScrollPos2nd = ORDERINDEX_INVALID;
 					SetFocus();
-					SetCurSel(m_nXScroll + (pt.x - rect.left) / m_cxFont);
+					SetCurSel(GetOrderFromPoint(rect, pt));
 				}
 			}
 		}
@@ -752,8 +759,8 @@
 		if (rect.PtInRect(pt))
 		{
 			CSoundFile *pSndFile = m_pModDoc->GetSoundFile();
-			n = m_nXScroll + (pt.x - rect.left) / m_cxFont;
-			if (n >= int(pSndFile->Order.size()) || n >= pSndFile->GetModSpecifications().ordersMax) n = ORDERINDEX_INVALID;
+			n = GetOrderFromPoint(rect, pt);
+			if (n >= pSndFile->Order.GetLength() || n >= pSndFile->GetModSpecifications().ordersMax) n = ORDERINDEX_INVALID;
 		}
 		if (n != (int)m_nDropPos)
 		{
@@ -775,6 +782,43 @@
 }
 
 
+void COrderList::OnSelectSequence(UINT nid)
+//-----------------------------------------
+{
+	BEGIN_CRITICAL();
+	CMainFrame::GetMainFrame()->ResetNotificationBuffer();
+	const SEQUENCEINDEX nId = static_cast<SEQUENCEINDEX>(nid - ID_SEQUENCE_ITEM);
+	CSoundFile& rSf = *m_pModDoc->GetSoundFile();
+	if (nId == MAX_SEQUENCES + 1)
+	{
+		CString strParam; strParam.Format(TEXT("%u: %s"), rSf.Order.GetCurrentSequenceIndex(), rSf.Order.m_sName);
+		CString str;
+		AfxFormatString1(str, IDS_CONFIRM_SEQUENCE_DELETE, strParam);
+		if (AfxMessageBox(str, MB_YESNO | MB_ICONQUESTION) == IDYES)
+			rSf.Order.RemoveSequence();
+		else
+		{
+			END_CRITICAL();
+			return;
+		}
+	}
+	else if (nId == MAX_SEQUENCES)
+		rSf.Order.AddSequence();
+	else if (nId < rSf.Order.GetNumSequences())
+		rSf.Order.SetSequence(nId);
+	ORDERINDEX nPosCandidate = rSf.Order.GetLengthTailTrimmed() - 1;
+	SetCurSel(min(m_nScrollPos, nPosCandidate), true, false, true);
+	if (m_pParent)
+		m_pParent->SetCurrentPattern(rSf.Order[m_nScrollPos]);
+
+	UpdateScrollInfo();
+	END_CRITICAL();
+	UpdateView(HINT_MODSEQUENCE);
+	m_pModDoc->SetModified();
+	m_pModDoc->UpdateAllViews(NULL, HINT_MODSEQUENCE, this);
+}
+
+
 void COrderList::OnRButtonDown(UINT nFlags, CPoint pt)
 //----------------------------------------------------
 {
@@ -791,7 +835,7 @@
 
 	bool bMultiSelection = (m_nScrollPos2nd != ORDERINDEX_INVALID);
 
-	if(!bMultiSelection) SetCurSel(m_nXScroll + (pt.x - rect.left) / m_cxFont);
+	if(!bMultiSelection) SetCurSel(GetOrderFromPoint(rect, pt));
 	SetFocus();
 	HMENU hMenu = ::CreatePopupMenu();
 	if(!hMenu) return;
@@ -826,11 +870,31 @@
 		AppendMenu(hMenu, MF_STRING | greyed, ID_ORDERLIST_COPY, "&Duplicate Pattern");
 		AppendMenu(hMenu, MF_STRING | greyed, ID_PATTERNCOPY, "&Copy Pattern");
 		AppendMenu(hMenu, MF_STRING | greyed, ID_PATTERNPASTE, "P&aste Pattern");
-		if ((m_pModDoc) && (m_pModDoc->GetSoundFile()->m_nType & (MOD_TYPE_XM|MOD_TYPE_IT|MOD_TYPE_MPT)))
+		if (pSndFile->TypeIsIT_MPT_XM())
 		{
 			AppendMenu(hMenu, MF_SEPARATOR, NULL, "");
-			AppendMenu(hMenu, MF_STRING | greyed, ID_PATTERN_PROPERTIES, "&Properties...");
+			AppendMenu(hMenu, MF_STRING | greyed, ID_PATTERN_PROPERTIES, "&Pattern properties...");
 		}
+		if (pSndFile->GetType() == MOD_TYPE_MPT)
+		{
+			AppendMenu(hMenu, MF_SEPARATOR, NULL, "");
+
+			HMENU menuSequence = ::CreatePopupMenu();
+			AppendMenu(hMenu, MF_POPUP, (UINT_PTR)menuSequence, TEXT("Sequences"));
+			
+			const SEQUENCEINDEX numSequences = pSndFile->Order.GetNumSequences();
+			for(SEQUENCEINDEX i = 0; i < numSequences; i++)
+			{
+				CString str;
+				str.Format(TEXT("%u: %s"), i, (LPCTSTR)pSndFile->Order.GetSequence(i).m_sName);
+				const UINT flags = (pSndFile->Order.GetCurrentSequenceIndex() == i) ? MF_STRING|MF_CHECKED : MF_STRING;
+				AppendMenu(menuSequence, flags, ID_SEQUENCE_ITEM + i, str);
+			}
+			if (pSndFile->Order.GetNumSequences() < MAX_SEQUENCES)
+				AppendMenu(menuSequence, MF_STRING, ID_SEQUENCE_ITEM + MAX_SEQUENCES, TEXT("Create new sequence"));
+			if (pSndFile->Order.GetNumSequences() > 1)
+				AppendMenu(menuSequence, MF_STRING, ID_SEQUENCE_ITEM + MAX_SEQUENCES + 1, TEXT("Delete current sequence"));
+		}
 	}
 	AppendMenu(hMenu, MF_SEPARATOR, NULL, "");
 	AppendMenu(hMenu, MF_STRING, ID_ORDERLIST_RENDER, "Render to &Wave");
@@ -857,7 +921,7 @@
 void COrderList::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar*)
 //--------------------------------------------------------------
 {
-	ORDERINDEX nNewPos = m_nXScroll;
+	UINT nNewPos = m_nXScroll;
 	UINT smin, smax;
 	
 	GetScrollRange(SB_HORZ, (LPINT)&smin, (LPINT)&smax);
@@ -874,9 +938,9 @@
 	case SB_ENDSCROLL:		m_bScrolling = false; break;
 	}
 	if (nNewPos > smax) nNewPos = smax;
-	if (nNewPos != (UINT)m_nXScroll)
+	if (nNewPos != m_nXScroll)
 	{
-		m_nXScroll = nNewPos;
+		m_nXScroll = static_cast<ORDERINDEX>(nNewPos);
 		SetScrollPos(SB_HORZ, m_nXScroll);
 		InvalidateRect(NULL, FALSE);
 	}
@@ -886,17 +950,17 @@
 void COrderList::OnSize(UINT nType, int cx, int cy)
 //-------------------------------------------------
 {
-	ORDERINDEX nPos;
+	int nPos;
 	int smin, smax;
 
 	CWnd::OnSize(nType, cx, cy);
 	UpdateScrollInfo();
 	GetScrollRange(SB_HORZ, &smin, &smax);
-	nPos = (ORDERINDEX)GetScrollPos(SB_HORZ);
+	nPos = GetScrollPos(SB_HORZ);
 	if (nPos > smax) nPos = smax;
 	if (m_nXScroll != nPos)
 	{
-		m_nXScroll = nPos;
+		m_nXScroll = static_cast<ORDERINDEX>(nPos);
 		SetScrollPos(SB_HORZ, m_nXScroll);
 		InvalidateRect(NULL, FALSE);
 	}
@@ -916,25 +980,26 @@
 
 		for(ORDERINDEX i = 0; i <= nInsertCount; i++)
 		{
-
 			//Checking whether there is some pattern at the end of orderlist.
-			if(pSndFile->Order[pSndFile->Order.size() - 1] < pSndFile->Patterns.Size())
+			if (pSndFile->Order.GetLength() < 1 || pSndFile->Order.Last() < pSndFile->Patterns.Size())
 			{
-				if(pSndFile->Order.size() < pSndFile->GetModSpecifications().ordersMax)
-					pSndFile->Order.push_back(pSndFile->Order.GetInvalidPatIndex());
+				if(pSndFile->Order.GetLength() < pSndFile->GetModSpecifications().ordersMax)
+					pSndFile->Order.Append();
 			}
-
-			for(int j = pSndFile->Order.size() - 1; j > nInsertEnd; j--) pSndFile->Order[j] = pSndFile->Order[j - 1];
+			for(int j = pSndFile->Order.GetLastIndex(); j > nInsertEnd; j--)
+				pSndFile->Order[j] = pSndFile->Order[j - 1];
 		}
 		// now that there is enough space in the order list, overwrite the orders
 		for(ORDERINDEX i = 0; i <= nInsertCount; i++)
 		{
-			if(nInsertEnd + i + 1 < pSndFile->GetModSpecifications().ordersMax)
+			if(nInsertEnd + i + 1 < pSndFile->GetModSpecifications().ordersMax
+			   && 
+			   nInsertEnd + i + 1 < pSndFile->Order.GetLength())
 				pSndFile->Order[nInsertEnd + i + 1] = pSndFile->Order[nInsertEnd - nInsertCount + i];
 		}
-		m_nScrollPos = min(nInsertEnd + 1, pSndFile->Order.GetCount() - 1);
+		m_nScrollPos = min(nInsertEnd + 1, pSndFile->Order.GetLastIndex());
 		if(nInsertCount > 0)
-			m_nScrollPos2nd = min(m_nScrollPos + nInsertCount, pSndFile->Order.GetCount() - 1);
+			m_nScrollPos2nd = min(m_nScrollPos + nInsertCount, pSndFile->Order.GetLastIndex());
 		else
 			m_nScrollPos2nd = ORDERINDEX_INVALID;
 		InvalidateRect(NULL, FALSE);
@@ -1053,7 +1118,7 @@
 //-----------------------------------------------------------------
 {
 	LPDRAGONDROP pDropInfo = (LPDRAGONDROP)lParam;
-	UINT posdest;
+	ORDERINDEX posdest;
 	BOOL bCanDrop;
 	CSoundFile *pSndFile;
 	CPoint pt;
@@ -1073,8 +1138,8 @@
 	GetCursorPos(&pt);
 	ScreenToClient(&pt);
 	if (pt.x < 0) pt.x = 0;
-	posdest = m_nXScroll + (pt.x / m_cxFont);
-	if (posdest >= pSndFile->Order.size()) return FALSE;
+	posdest = static_cast<ORDERINDEX>(m_nXScroll + (pt.x / m_cxFont));
+	if (posdest >= pSndFile->Order.GetLength()) return FALSE;
 	switch(pDropInfo->dwDropType)
 	{
 	case DRAGONDROP_PATTERN:

Modified: trunk/OpenMPT/mptrack/Draw_pat.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Draw_pat.cpp	2009-09-15 22:10:35 UTC (rev 365)
+++ trunk/OpenMPT/mptrack/Draw_pat.cpp	2009-09-16 19:05:00 UTC (rev 366)
@@ -620,7 +620,7 @@
 			ORDERINDEX nNextOrder;
 			nNextOrder = pSndFile->Order.GetNextOrderIgnoringSkips(startOrder);
 			//Ignore skip items(+++) from sequence.
-			const ORDERINDEX ordCount = pSndFile->Order.GetCount();
+			const ORDERINDEX ordCount = pSndFile->Order.GetLength();
 
 			if ((nNextOrder < ordCount) && (pSndFile->Order[startOrder] == m_nPattern))
 			{

Modified: trunk/OpenMPT/mptrack/Moddoc.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Moddoc.cpp	2009-09-15 22:10:35 UTC (rev 365)
+++ trunk/OpenMPT/mptrack/Moddoc.cpp	2009-09-16 19:05:00 UTC (rev 366)
@@ -2977,7 +2977,7 @@
 	//ensure order correlates with pattern.
 	if (pSndFile->Order[ord]!=pat) {
 		ORDERINDEX tentativeOrder = pSndFile->FindOrder(pat);
-		if (tentativeOrder != -1) {	//ensure a valid order exists.
+		if (tentativeOrder != ORDERINDEX_INVALID) {	//ensure a valid order exists.
 			ord = tentativeOrder;
 		}
 	}

Modified: trunk/OpenMPT/mptrack/Modedit.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Modedit.cpp	2009-09-15 22:10:35 UTC (rev 365)
+++ trunk/OpenMPT/mptrack/Modedit.cpp	2009-09-16 19:05:00 UTC (rev 366)
@@ -940,6 +940,12 @@
 BOOL CModDoc::RemoveUnusedPatterns(BOOL bRemove)
 //----------------------------------------------
 {
+	if (GetSoundFile()->GetType() == MOD_TYPE_MPT && GetSoundFile()->Order.GetNumSequences() > 1)
+	{   // Multiple sequences are not taken into account in the code below. For now just make
+		// removing unused patterns disabled in this case.
+		AfxMessageBox(IDS_PATTERN_CLEANUP_UNAVAILABLE, MB_ICONINFORMATION);
+		return FALSE;
+	}
 	const UINT maxPatIndex = m_SndFile.Patterns.Size();
 	const UINT maxOrdIndex = m_SndFile.Order.size();
 	vector<UINT> nPatMap(maxPatIndex, 0);
@@ -1668,10 +1674,10 @@
 	//Increasing orderlist size if given order is beyond current limit,
 	//or if the last order already has a pattern.
 	if((nOrd == m_SndFile.Order.size() ||
-		m_SndFile.Order.back() < m_SndFile.Patterns.Size() ) &&
-		m_SndFile.Order.size() < m_SndFile.GetModSpecifications().ordersMax)
+		m_SndFile.Order.Last() < m_SndFile.Patterns.Size() ) &&
+		m_SndFile.Order.GetLength() < m_SndFile.GetModSpecifications().ordersMax)
 	{
-		m_SndFile.Order.push_back(m_SndFile.Order.GetInvalidPatIndex());
+		m_SndFile.Order.Append();
 	}
 
 	for (UINT j=0; j<m_SndFile.Order.size(); j++)

Modified: trunk/OpenMPT/mptrack/View_pat.cpp
===================================================================
--- trunk/OpenMPT/mptrack/View_pat.cpp	2009-09-15 22:10:35 UTC (rev 365)
+++ trunk/OpenMPT/mptrack/View_pat.cpp	2009-09-16 19:05:00 UTC (rev 366)
@@ -2853,9 +2853,6 @@
 }
 
 
-
-
-
 LRESULT CViewPattern::OnPlayerNotify(MPTNOTIFICATION *pnotify)
 //------------------------------------------------------------
 {
@@ -2897,7 +2894,7 @@
 		}
 		*/
 
-		if (pSndFile->Order[nOrd] != nPat) {
+		if (nOrd >= pSndFile->Order.GetLength() || pSndFile->Order[nOrd] != nPat) {
 			//order doesn't correlate with pattern, so mark it as invalid
 			nOrd = 0xFFFF;
 		}

Modified: trunk/OpenMPT/mptrack/View_tre.cpp
===================================================================
--- trunk/OpenMPT/mptrack/View_tre.cpp	2009-09-15 22:10:35 UTC (rev 365)
+++ trunk/OpenMPT/mptrack/View_tre.cpp	2009-09-16 19:05:00 UTC (rev 366)
@@ -688,8 +688,12 @@
 	if ((pInfo->hOrders) && (hintFlagPart != HINT_INSNAMES) && (hintFlagPart != HINT_SMPNAMES))
 	{
 		const DWORD nPat = (lHint >> HINT_SHIFT_PAT);
-		pInfo->tiOrders.resize(pSndFile->Order.size(), NULL);
-		UINT imin=0, imax=pSndFile->Order.size()-1;
+		// If there are items past the new sequence length, delete them.
+		for(size_t i = pSndFile->Order.GetLength(); i < pInfo->tiOrders.size(); i++) if (pInfo->tiOrders[i])
+			{DeleteItem(pInfo->tiOrders[i]); pInfo->tiOrders[i] = NULL;}
+		if (pInfo->tiOrders.size() < pSndFile->Order.GetLength()) // Resize tiOrders if needed.
+			pInfo->tiOrders.resize(pSndFile->Order.GetLength(), NULL);
+		UINT imin=0, imax = pSndFile->Order.GetLastIndex();
 		const bool patNamesOnly = (hintFlagPart == HINT_PATNAMES);
 		//if (hintFlagPart == HINT_PATNAMES) && (dwHintParam < pSndFile->Order.size())) imin = imax = dwHintParam;
 		BOOL bEnded = FALSE;
@@ -1260,53 +1264,53 @@
 //--------------------------------------------
 {
 	DWORD dwItemType = GetModItem(hItem);
-	DWORD dwItem = dwItemType >> 16;
+	WORD nItem = WORD(dwItemType >> 16);
 	PMODTREEDOCINFO pInfo = DocInfo[m_nDocNdx];
 	CModDoc *pModDoc = (pInfo) ? pInfo->pModDoc : NULL;
 	switch(dwItemType & 0xFFFF)
 	{
 	case MODITEM_ORDER:
-		if ((pModDoc) && (pModDoc->RemoveOrder(dwItem)))
+		if ((pModDoc) && (pModDoc->RemoveOrder(nItem)))
 		{
 			pModDoc->UpdateAllViews(NULL, HINT_MODSEQUENCE, NULL);
 		}
 		break;
 
 	case MODITEM_PATTERN:
-		if ((pModDoc) && (pModDoc->RemovePattern(dwItem)))
+		if ((pModDoc) && (pModDoc->RemovePattern(nItem)))
 		{
 			//pModDoc->UpdateAllViews(NULL, (dwItem << 16)|HINT_PATTERNDATA|HINT_PATNAMES);
-			pModDoc->UpdateAllViews(NULL, (dwItem << HINT_SHIFT_PAT) | HINT_PATTERNDATA|HINT_PATNAMES);
+			pModDoc->UpdateAllViews(NULL, (UINT(nItem) << HINT_SHIFT_PAT) | HINT_PATTERNDATA|HINT_PATNAMES);
 		}
 		break;
 
 	case MODITEM_SAMPLE:
-		if ((pModDoc) && (pModDoc->RemoveSample(dwItem)))
+		if ((pModDoc) && (pModDoc->RemoveSample(nItem)))
 		{
 			//pModDoc->UpdateAllViews(NULL, (dwItem << 16) | HINT_SMPNAMES|HINT_SAMPLEDATA|HINT_SAMPLEINFO);
-			pModDoc->UpdateAllViews(NULL, (dwItem << HINT_SHIFT_SMP) | HINT_SMPNAMES|HINT_SAMPLEDATA|HINT_SAMPLEINFO);
+			pModDoc->UpdateAllViews(NULL, (UINT(nItem) << HINT_SHIFT_SMP) | HINT_SMPNAMES|HINT_SAMPLEDATA|HINT_SAMPLEINFO);
 		}
 		break;
 
 	case MODITEM_INSTRUMENT:
-		if ((pModDoc) && (pModDoc->RemoveInstrument(dwItem)))
+		if ((pModDoc) && (pModDoc->RemoveInstrument(nItem)))
 		{
 			//pModDoc->UpdateAllViews(NULL, (dwItem << 16)|HINT_MODTYPE|HINT_ENVELOPE|HINT_INSTRUMENT);
-			pModDoc->UpdateAllViews(NULL, (dwItem << HINT_SHIFT_INS) | HINT_MODTYPE|HINT_ENVELOPE|HINT_INSTRUMENT);
+			pModDoc->UpdateAllViews(NULL, (UINT(nItem) << HINT_SHIFT_INS) | HINT_MODTYPE|HINT_ENVELOPE|HINT_INSTRUMENT);
 		}
 		break;
 
 	case MODITEM_MIDIINSTRUMENT:
-		SetMidiInstrument(dwItem, "");
+		SetMidiInstrument(nItem, "");
 		RefreshMidiLibrary();
 		break;
 	case MODITEM_MIDIPERCUSSION:
-		SetMidiPercussion(dwItem, "");
+		SetMidiPercussion(nItem, "");
 		RefreshMidiLibrary();
 		break;
 
 	case MODITEM_DLSBANK_FOLDER:
-		CTrackApp::RemoveDLSBank(dwItem);
+		CTrackApp::RemoveDLSBank(nItem);
 		RefreshDlsBanks();
 		break;
 
@@ -2147,7 +2151,7 @@
 					if (pSndFile) {
 						PSNDMIXPLUGIN pPlugin = &pSndFile->m_MixPlugins[dwItemNo];
 						if (pPlugin) {
-							bool bypassed = pPlugin->Info.dwInputRouting&MIXPLUG_INPUTF_BYPASS;
+							bool bypassed = ((pPlugin->Info.dwInputRouting&MIXPLUG_INPUTF_BYPASS) != 0);
 							AppendMenu(hMenu, (bypassed?MF_CHECKED:0)|MF_STRING, ID_MODTREE_MUTE, "&Bypass");
 						}
 					}

Modified: trunk/OpenMPT/mptrack/View_tre.h
===================================================================
--- trunk/OpenMPT/mptrack/View_tre.h	2009-09-15 22:10:35 UTC (rev 365)
+++ trunk/OpenMPT/mptrack/View_tre.h	2009-09-16 19:05:00 UTC (rev 366)
@@ -61,7 +61,7 @@
 		if(pSndFile != NULL)
 		{
 			tiPatterns.resize(pSndFile->Patterns.Size(), NULL);
-			tiOrders.resize(pSndFile->Order.size(), NULL);
+			tiOrders.resize(pSndFile->Order.GetLength(), NULL);
 		}
 		memset(tiSamples, 0, sizeof(tiSamples));
 		memset(tiInstruments, 0, sizeof(tiInstruments));

Modified: trunk/OpenMPT/mptrack/mptrack.rc
===================================================================
--- trunk/OpenMPT/mptrack/mptrack.rc	2009-09-15 22:10:35 UTC (rev 365)
+++ trunk/OpenMPT/mptrack/mptrack.rc	2009-09-16 19:05:00 UTC (rev 366)
@@ -358,8 +358,8 @@
     CONTROL         "Follow Song",IDC_PATTERN_FOLLOWSONG,"Button",BS_AUTOCHECKBOX | BS_LEFTTEXT | BS_FLAT,432,34,55,10
     COMBOBOX        IDC_COMBO_INSTRUMENT,22,74,95,137,CBS_DROPDOWNLIST | WS_VSCROLL
     CTEXT           "Row spacing",IDC_STATIC,172,32,54,12,SS_CENTERIMAGE,WS_EX_STATICEDGE
-    EDITTEXT        IDC_EDIT_SPACING,225,32,40,12,ES_AUTOHSCROLL | ES_NUMBER | NOT WS_TABSTOP
-    CONTROL         "Spin1",IDC_SPIN_SPACING,"msctls_updown32",UDS_WRAP | UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | UDS_NOTHOUSANDS,256,33,9,11
+    EDITTEXT        IDC_EDIT_SPACING,225,32,28,12,ES_AUTOHSCROLL | ES_NUMBER | NOT WS_TABSTOP
+    CONTROL         "Spin1",IDC_SPIN_SPACING,"msctls_updown32",UDS_WRAP | UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | UDS_NOTHOUSANDS,245,32,11,11
     PUSHBUTTON      "<<",IDC_BUTTON2,2,99,14,15,NOT WS_TABSTOP,WS_EX_STATICEDGE
     PUSHBUTTON      ">>",IDC_BUTTON1,14,99,14,15,NOT WS_TABSTOP,WS_EX_STATICEDGE
     CTEXT           "Pattern name",IDC_STATIC,9,32,52,12,SS_CENTERIMAGE,WS_EX_STATICEDGE
@@ -380,9 +380,11 @@
     GROUPBOX        "Keyboard Split",IDC_STATIC,167,53,328,40
     LTEXT           "Octave shift",IDC_STATIC,382,65,52,8
     GROUPBOX        "",IDC_STATIC,2,22,493,27
-    CONTROL         "Loop Pattern",IDC_PATTERN_LOOP,"Button",BS_AUTOCHECKBOX | BS_LEFTTEXT | BS_FLAT | WS_TABSTOP,355,34,57,10
+    CONTROL         "Loop Pattern",IDC_PATTERN_LOOP,"Button",BS_AUTOCHECKBOX | BS_LEFTTEXT | BS_FLAT | WS_TABSTOP,370,34,55,10
     EDITTEXT        IDC_EDIT_ORDERLIST_MARGINS,2,113,28,12,ES_AUTOHSCROLL | ES_READONLY
     CONTROL         "",IDC_SPIN_ORDERLIST_MARGINS,"msctls_updown32",UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | UDS_NOTHOUSANDS,15,118,11,11
+    EDITTEXT        IDC_EDIT_SEQUENCE_NAME,317,32,47,12,ES_AUTOHSCROLL
+    CTEXT           "Sequence name",IDC_STATIC_SEQUENCE_NAME,261,32,55,12,SS_CENTERIMAGE,WS_EX_STATICEDGE
 END
 
 IDD_CONTROL_SAMPLES DIALOGEX 0, 0, 544, 106
@@ -2211,6 +2213,9 @@
     IDS_UNABLE_TO_LOAD_KEYBINDINGS 
                             "Loading keybindings failed. The keyboard won't work properly."
     IDS_CANT_OPEN_FILE_FOR_WRITING "Can't open file for writing."
+    IDS_CONFIRM_SEQUENCE_DELETE "Delete sequence %1?"
+    IDS_PATTERN_CLEANUP_UNAVAILABLE 
+                            "Removing unused patterns is not available when using multiple sequences."
 END
 
 #endif    // English (U.S.) resources

Modified: trunk/OpenMPT/mptrack/resource.h
===================================================================
--- trunk/OpenMPT/mptrack/resource.h	2009-09-15 22:10:35 UTC (rev 365)
+++ trunk/OpenMPT/mptrack/resource.h	2009-09-16 19:05:00 UTC (rev 366)
@@ -50,6 +50,8 @@
 #define IDS_CANT_OPEN_KEYBINDING_FILE   211
 #define IDS_UNABLE_TO_LOAD_KEYBINDINGS  212
 #define IDS_CANT_OPEN_FILE_FOR_WRITING  213
+#define IDS_CONFIRM_SEQUENCE_DELETE     214
+#define IDS_PATTERN_CLEANUP_UNAVAILABLE 215
 #define IDB_MAINBAR                     300
 #define IDB_IMAGELIST                   301
 #define IDB_PATTERNS                    302
@@ -885,6 +887,8 @@
 #define IDC_CHECK_PATRECORD             2386
 #define IDC_LOAD_COLORSCHEME            2387
 #define IDC_SAVE_COLORSCHEME            2388
+#define IDC_EDIT_SEQUENCE_NAME          2389
+#define IDC_STATIC_SEQUENCE_NAME        2390
 #define ID_FILE_NEWMOD                  32771
 #define ID_FILE_NEWXM                   32772
 #define ID_FILE_NEWS3M                  32773
@@ -1078,6 +1082,7 @@
 #define ID_CLEAR_SELECTION              38000
 #define ID_PLUG_PASSKEYS                38001
 #define ID_VIEW_SONGPROPERTIES          38002
+#define ID_SEQUENCE_ITEM                38003
 #define ID_GROW_SELECTION               40001
 #define ID_SHRINK_SELECTION             40002
 #define ID_RUN_SCRIPT                   40003
@@ -1127,7 +1132,7 @@
 #define _APS_3D_CONTROLS                     1
 #define _APS_NEXT_RESOURCE_VALUE        521
 #define _APS_NEXT_COMMAND_VALUE         59230
-#define _APS_NEXT_CONTROL_VALUE         2389
+#define _APS_NEXT_CONTROL_VALUE         2391
 #define _APS_NEXT_SYMED_VALUE           901
 #endif
 #endif

Modified: trunk/OpenMPT/mptrack/serialization_utils.cpp
===================================================================
--- trunk/OpenMPT/mptrack/serialization_utils.cpp	2009-09-15 22:10:35 UTC (rev 365)
+++ trunk/OpenMPT/mptrack/serialization_utils.cpp	2009-09-16 19:05:00 UTC (rev 366)
@@ -131,15 +131,15 @@
 }
 
 
-void WriteItemString(OutStream& oStrm, const std::string& str)
-//------------------------------------------------------------
+void WriteItemString(OutStream& oStrm, const char* const pStr, const size_t nSize)
+//--------------------------------------------------------------------------------
 {
-	uint32 id = (std::min)(str.size(), (uint32_max >> 4)) << 4;
+	uint32 id = (std::min)(nSize, (uint32_max >> 4)) << 4;
 	id |= 12; // 12 == 1100b
 	Binarywrite<uint32>(oStrm, id);
 	id >>= 4;
 	if(id > 0)
-		oStrm.write(str.c_str(), id);
+		oStrm.write(pStr, id);
 }
 
 

Modified: trunk/OpenMPT/mptrack/serialization_utils.h
===================================================================
--- trunk/OpenMPT/mptrack/serialization_utils.h	2009-09-15 22:10:35 UTC (rev 365)
+++ trunk/OpenMPT/mptrack/serialization_utils.h	2009-09-16 19:05:00 UTC (rev 366)
@@ -344,11 +344,13 @@
 	Binarywrite(oStrm, data);
 }
 
-void WriteItemString(OutStream& oStrm, const std::string& str);
+void WriteItemString(OutStream& oStrm, const char* const pStr, const size_t nSize);
 
 template <>
-inline void WriteItem<std::string>(OutStream& oStrm, const std::string& str) {WriteItemString(oStrm, str);}
+inline void WriteItem<std::string>(OutStream& oStrm, const std::string& str) {WriteItemString(oStrm, str.c_str(), str.length());}
 
+template <>
+inline void WriteItem<LPCSTR>(OutStream& oStrm, const LPCSTR& psz) {WriteItemString(oStrm, psz, strlen(psz));}
 
 template<class T>
 inline void Binaryread(InStream& iStrm, T& data)
@@ -416,6 +418,25 @@
 	ReadItemString(iStrm, str, nSize);
 }
 
+
+template <class T>
+struct ArrayWriter
+//================
+{
+	ArrayWriter(size_t nCount) : m_nCount(nCount) {}
+	void operator()(srlztn::OutStream& oStrm, const T* pData) {oStrm.write(reinterpret_cast<const char*>(pData), m_nCount * sizeof(T));} 
+	size_t m_nCount;
+};
+
+template <class T>
+struct ArrayReader
+//================
+{
+	ArrayReader(size_t nCount) : m_nCount(nCount) {}
+	void operator()(srlztn::InStream& iStrm, T* pData, const size_t) {iStrm.read(reinterpret_cast<char*>(pData), m_nCount * sizeof(T));} 
+	size_t m_nCount;
+};
+
 } //namespace srlztn.
 
 

Modified: trunk/OpenMPT/soundlib/Load_it.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_it.cpp	2009-09-15 22:10:35 UTC (rev 365)
+++ trunk/OpenMPT/soundlib/Load_it.cpp	2009-09-16 19:05:00 UTC (rev 366)
@@ -1004,8 +1004,8 @@
 			Order.ReadAsByte(lpStream + dwMemPos, nordsize, dwMemLength - dwMemPos);
 			dwMemPos += pifh->ordnum;
 			//Replacing 0xFF and 0xFE with new corresponding indexes
-			replace(Order.begin(), Order.end(), static_cast<PATTERNINDEX>(0xFE), Order.GetIgnoreIndex());
-			replace(Order.begin(), Order.end(), static_cast<PATTERNINDEX>(0xFF), Order.GetInvalidPatIndex());
+			Order.Replace(0xFE, Order.GetIgnoreIndex());
+			Order.Replace(0xFF, Order.GetInvalidPatIndex());
 		}
 	}
 
@@ -1493,8 +1493,9 @@
 				ssb.BeginRead("mptm", 1);
 				ssb.ReadItem(GetTuneSpecificTunings(), "0", 1, &ReadTuningCollection);
 				ssb.ReadItem(*this, "1", 1, &ReadTuningMap);
-				ssb.ReadItem(Order, "2", 1, &ReadModSequence);
+				ssb.ReadItem(Order, "2", 1, &ReadModSequenceOld);
 				ssb.ReadItem(Patterns, FileIdPatterns, strlen(FileIdPatterns), &ReadModPatterns);
+				ssb.ReadItem(Order, FileIdSequences, strlen(FileIdSequences), &ReadModSequences);
 
 				if (ssb.m_Status & srlztn::SNT_FAILURE)
 					AfxMessageBox("Unknown error occured.", MB_ICONERROR);
@@ -2421,9 +2422,10 @@
 	if (AreNonDefaultTuningsUsed(*this))
 		ssb.WriteItem(*this, "1", 1, &WriteTuningMap);
 	if (Order.NeedsExtraDatafield())
-		ssb.WriteItem(Order, "2", 1, &WriteModSequence);
+		ssb.WriteItem(Order, "2", 1, &WriteModSequenceOld);
 	if (bNeedsMptPatSave)
 		ssb.WriteItem(Patterns, FileIdPatterns, strlen(FileIdPatterns), &WriteModPatterns);
+	ssb.WriteItem(Order, FileIdSequences, strlen(FileIdSequences), &WriteModSequences);
 
 	ssb.FinishWrite();
 
@@ -3463,6 +3465,9 @@
 
 	code = 'MPTX';							// write extension header code
 	fwrite(&code, 1, sizeof(__int32), f);		
+
+	if (nInstruments == 0)
+		return;
 	
 	WriteInstrumentPropertyForAllInstruments('VR..', sizeof(m_defaultInstrument.nVolRamp),    f, instruments, nInstruments);
 	WriteInstrumentPropertyForAllInstruments('MiP.', sizeof(m_defaultInstrument.nMixPlug),    f, instruments, nInstruments);

Modified: trunk/OpenMPT/soundlib/Load_psm.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_psm.cpp	2009-09-15 22:10:35 UTC (rev 365)
+++ trunk/OpenMPT/soundlib/Load_psm.cpp	2009-09-16 19:05:00 UTC (rev 366)
@@ -259,7 +259,7 @@
 
 												// every pattern in the order will be unique, so store the pointer + pattern ID
 												orderOffsets.push_back(patternOffsets[i]);
-												Order.push_back(numPatterns);
+												Order.Append(numPatterns);
 												numPatterns++;
 												break;
 											}
@@ -359,7 +359,7 @@
 							}
 							// separate subsongs by "---" patterns
 							orderOffsets.push_back(nullptr);
-							Order.push_back(Order.GetInvalidPatIndex());
+							Order.Append();
 						}
 						break;
 

Modified: trunk/OpenMPT/soundlib/Load_xm.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_xm.cpp	2009-09-15 22:10:35 UTC (rev 365)
+++ trunk/OpenMPT/soundlib/Load_xm.cpp	2009-09-16 19:05:00 UTC (rev 366)
@@ -737,8 +737,8 @@
 		header.norder++;
 		if ((Order[i] >= header.patterns) && (Order[i] < MAX_PATTERNS)) header.patterns = Order[i]+1;
 	}*/
-	if(Order.GetCount() < MAX_ORDERS)
-		Order.resize(MAX_ORDERS, Order.GetInvalidPatIndex());
+	if(Order.GetLength() < MAX_ORDERS)
+		Order.resize(MAX_ORDERS);
 
 	for (i=MAX_ORDERS-1; i>=0; i--) { // walk backwards over orderlist
 		if ((Order[i]!=0xFF) && (header.norder==0)) {

Modified: trunk/OpenMPT/soundlib/ModSequence.cpp
===================================================================
--- trunk/OpenMPT/soundlib/ModSequence.cpp	2009-09-15 22:10:35 UTC (rev 365)
+++ trunk/OpenMPT/soundlib/ModSequence.cpp	2009-09-16 19:05:00 UTC (rev 366)
@@ -1,127 +1,96 @@
 #include "stdafx.h"
 #include "sndfile.h"
 #include "ModSequence.h"
+#include "../mptrack/version.h"
 #include "../mptrack/serialization_utils.h"
 
 #define str_SequenceTruncationNote (GetStrI18N((_TEXT("Module has sequence of length %u; it will be truncated to maximum supported length, %u."))))
 
-DWORD COrderToPatternTable::Deserialize(const BYTE* const src, const DWORD memLength)
-//-------------------------------------------------------------------------
-{
-	if(memLength < 2 + 4) return 0;
-	uint16 version = 0;
-	uint32 s = 0;
-	DWORD memPos = 0;
-	memcpy(&version, src, sizeof(version));
-	memPos += sizeof(version);
-	if(version != 0) return memPos;
-    memcpy(&s, src+memPos, sizeof(s));
-	memPos += sizeof(s);
-	if(s > 65000) return true;
-	if(memLength < memPos+s*4) return memPos;
+#define new DEBUG_NEW
 
-	const uint32 nOriginalSize = s;
-	if(s > ModSpecs::mptm.ordersMax)
-		s = ModSpecs::mptm.ordersMax;
 
-	resize(max(s, MAX_ORDERS));
-	for(size_t i = 0; i<s; i++, memPos +=4 )
-	{
-		uint32 temp;
-		memcpy(&temp, src+memPos, 4);
-		(*this)[i] = static_cast<PATTERNINDEX>(temp);
-	}
-	memPos += 4*(nOriginalSize - s);
-	return memPos;
-}
+ModSequence::ModSequence(const CSoundFile& rSf,
+						 PATTERNINDEX* pArray,
+						 ORDERINDEX nSize,
+						 ORDERINDEX nCapacity, 
+						 const bool bDeletableArray) : 
+		m_pSndFile(&rSf),
+		m_pArray(pArray),
+		m_nSize(nSize),
+		m_nCapacity(nCapacity),
+		m_bDeletableArray(bDeletableArray),
+		m_nInvalidIndex(0xFF),
+		m_nIgnoreIndex(0xFE)
+//-------------------------------------------------------
+{}
 
 
-size_t COrderToPatternTable::WriteToByteArray(BYTE* dest, const UINT numOfBytes, const UINT destSize)
-//-----------------------------------------------------------------------------
+ModSequence::ModSequence(const CSoundFile& rSf, ORDERINDEX nSize) : 
+	m_pSndFile(&rSf),
+	m_bDeletableArray(true),
+	m_nInvalidIndex(GetInvalidPatIndex(MOD_TYPE_MPT)),
+	m_nIgnoreIndex(GetIgnoreIndex(MOD_TYPE_MPT))
+//-------------------------------------------------------------------
 {
-	if(numOfBytes > destSize) return true;
-	if(size() < numOfBytes) resize(numOfBytes, 0xFF);
-	UINT i = 0;
-	for(i = 0; i<numOfBytes; i++)
-	{
-		dest[i] = static_cast<BYTE>((*this)[i]);
-	}
-	return i; //Returns the number of bytes written.
+	m_nSize = nSize;
+	m_nCapacity = m_nSize;
+	m_pArray = new PATTERNINDEX[m_nCapacity];
+	std::fill(begin(), end(), GetInvalidPatIndex(MOD_TYPE_MPT));
 }
 
 
-size_t COrderToPatternTable::WriteAsByte(FILE* f, const UINT count)
-//---------------------------------------------------------------
+ModSequence::ModSequence(const ModSequence& seq) :
+	m_pSndFile(seq.m_pSndFile),
+	m_bDeletableArray(false),
+	m_nInvalidIndex(0xFF),
+	m_nIgnoreIndex(0xFE),
+	m_nSize(0),
+	m_nCapacity(0),
+	m_pArray(nullptr)
+//------------------------------------------
 {
-	if(size() < count) resize(count, GetInvalidPatIndex());
-
-	size_t i = 0;
-	
-	for(i = 0; i<count; i++)
-	{
-		const PATTERNINDEX pat = (*this)[i];
-		BYTE temp = static_cast<BYTE>((*this)[i]);
-
-		if(pat > 0xFD)
-		{
-			if(pat == GetInvalidPatIndex()) temp = 0xFF;
-			else temp = 0xFE;
-		}
-		fwrite(&temp, 1, 1, f);
-	}
-	return i; //Returns the number of bytes written.
+	*this = seq;
 }
 
-bool COrderToPatternTable::ReadAsByte(const BYTE* pFrom, const int howMany, const int memLength)
-//-------------------------------------------------------------------------
-{
-	if(howMany < 0 || howMany > memLength) return true;
-	if(m_rSndFile.GetType() != MOD_TYPE_MPT && howMany > MAX_ORDERS) return true;
-	
-	if(size() < static_cast<size_t>(howMany))
-		resize(howMany, GetInvalidPatIndex());
-	
-	for(int i = 0; i<howMany; i++, pFrom++)
-		(*this)[i] = *pFrom;
-	return false;
-}
 
-
-bool COrderToPatternTable::NeedsExtraDatafield() const
-//----------------------------------------------
+bool ModSequence::NeedsExtraDatafield() const
+//-------------------------------------------
 {
-	if(m_rSndFile.GetType() == MOD_TYPE_MPT && m_rSndFile.Patterns.Size() > 0xFD)
+	if(m_pSndFile->GetType() == MOD_TYPE_MPT && m_pSndFile->Patterns.Size() > 0xFD)
 		return true;
 	else
 		return false;
 }
 
 
-void COrderToPatternTable::OnModTypeChanged(const MODTYPE oldtype)
-//----------------------------------------------------------------
+void ModSequence::OnModTypeChanged(const MODTYPE oldtype)
+//-------------------------------------------------------
 {
-	const CModSpecifications specs = m_rSndFile.GetModSpecifications();
+	const CModSpecifications specs = m_pSndFile->GetModSpecifications();
 
+	m_nInvalidIndex = GetInvalidPatIndex(m_pSndFile->GetType());
+	m_nIgnoreIndex = GetIgnoreIndex(m_pSndFile->GetType());
+
 	//Resize orderlist if needed. Because old orderlist had MAX_ORDERS(256) elements, not making it
 	//smaller than that even if the modtype doesn't support that many orders.
-	if(specs.ordersMax < GetCount()) 
+	if (specs.ordersMax < GetLength()) 
 	{
 		resize(max(MAX_ORDERS, specs.ordersMax));
-		for(ORDERINDEX i = GetCount(); i>specs.ordersMax; --i) (*this)[i-1] = GetInvalidPatIndex();
+		std::fill(begin() + specs.ordersMax, end(), GetInvalidPatIndex());
 	}
-	if (GetCount() < MAX_ORDERS)
-		resize(MAX_ORDERS, GetInvalidPatIndex());
+	if (GetLength() < MAX_ORDERS)
+		resize(MAX_ORDERS, GetInvalidPatIndex(oldtype));
 
 	//Replace items used to denote end of song/skip order.
-	replace(begin(), end(), GetInvalidPatIndex(oldtype), GetInvalidPatIndex());
-	replace(begin(), end(), GetIgnoreIndex(oldtype), GetIgnoreIndex());
+	Replace(GetInvalidPatIndex(oldtype),  GetInvalidPatIndex());
+	Replace(GetIgnoreIndex(oldtype),  GetIgnoreIndex());
 }
 
 
-ORDERINDEX COrderToPatternTable::GetLengthTailTrimmed() const
-//-----------------------------------------------------------
+ORDERINDEX ModSequence::GetLengthTailTrimmed() const
+//--------------------------------------------------
 {
-	ORDERINDEX nEnd = GetCount();
+	ORDERINDEX nEnd = GetLength();
 	if(nEnd == 0) return 0;
 	nEnd--;
 	const PATTERNINDEX iInvalid = GetInvalidPatIndex();
@@ -131,59 +100,275 @@
 }
 
 
-ORDERINDEX COrderToPatternTable::GetLengthFirstEmpty() const
-//----------------------------------------------------------
+ORDERINDEX ModSequence::GetLengthFirstEmpty() const
+//-------------------------------------------------
 {
-	const ORDERINDEX nLength = GetCount();
-	ORDERINDEX nMax = 0;
-	while ((nMax < nLength) && ((*this)[nMax] != (*this).GetInvalidPatIndex())) nMax++;
-	return nMax;
+	return static_cast<ORDERINDEX>(std::find(begin(), end(), GetInvalidPatIndex()) - begin());
 }
 
 
-ORDERINDEX COrderToPatternTable::GetNextOrderIgnoringSkips(const ORDERINDEX start) const
-//-------------------------------------------------------------------------------------
+ORDERINDEX ModSequence::GetNextOrderIgnoringSkips(const ORDERINDEX start) const
+//-----------------------------------------------------------------------------
 {
-	const ORDERINDEX count = GetCount();
-	if(count == 0) return 0;
-	ORDERINDEX next = min(count-1, start+1);
-	while(next+1 < count && (*this)[next] == GetIgnoreIndex()) next++;
+	const ORDERINDEX nLength = GetLength();
+	if(nLength == 0) return 0;
+	ORDERINDEX next = min(nLength-1, start+1);
+	while(next+1 < nLength && (*this)[next] == GetIgnoreIndex()) next++;
 	return next;
 }
 
-ORDERINDEX COrderToPatternTable::GetPreviousOrderIgnoringSkips(const ORDERINDEX start) const
-//-------------------------------------------------------------------------------------
+
+ORDERINDEX ModSequence::GetPreviousOrderIgnoringSkips(const ORDERINDEX start) const
+//---------------------------------------------------------------------------------
 {
-	const ORDERINDEX count = GetCount();
-	if(start == 0 || count == 0) return 0;
-	ORDERINDEX prev = min(start-1, count-1);
+	const ORDERINDEX nLength = GetLength();
+	if(start == 0 || nLength == 0) return 0;
+	ORDERINDEX prev = min(start-1, nLength-1);
 	while(prev > 0 && (*this)[prev] == GetIgnoreIndex()) prev--;
 	return prev;
 }
 
 
-void COrderToPatternTable::Init()
-//-------------------------------
+void ModSequence::Init()
+//----------------------
 {
-	resize(MAX_ORDERS, GetInvalidPatIndex());
-	for(ORDERINDEX i = 0; i < GetCount(); i++)
+	resize(MAX_ORDERS);
+	std::fill(begin(), end(), GetInvalidPatIndex());
+}
+
+
+void ModSequence::Append(PATTERNINDEX nPat)
+//-----------------------------------------
+{
+	resize(m_nSize + 1, nPat);
+}
+
+
+void ModSequence::resize(ORDERINDEX nNewSize, PATTERNINDEX nFill)
+//---------------------------------------------------------------
+{
+	if (nNewSize == m_nSize) return;
+	if (nNewSize <= m_nCapacity)
 	{
-		(*this)[i] = GetInvalidPatIndex();
+		if (nNewSize > m_nSize)
+			std::fill(begin() + m_nSize, begin() + nNewSize, nFill);
+		m_nSize = nNewSize;
 	}
+	else
+	{
+		const PATTERNINDEX* const pOld = m_pArray;
+		m_nCapacity = nNewSize + 100;
+		m_pArray = new PATTERNINDEX[m_nCapacity];
+		ArrayCopy(m_pArray, pOld, m_nSize);
+		std::fill(m_pArray + m_nSize, m_pArray + nNewSize, nFill);
+		m_nSize = nNewSize;
+		if (m_bDeletableArray)
+			delete[] pOld;
+		m_bDeletableArray = true;
+	}
 }
 
 
+void ModSequence::clear()
+//-----------------------
+{
+	m_nSize = 0;
+}
 
-PATTERNINDEX COrderToPatternTable::GetInvalidPatIndex(const MODTYPE type) {return type == MOD_TYPE_MPT ?  65535 : 0xFF;}
-PATTERNINDEX COrderToPatternTable::GetIgnoreIndex(const MODTYPE type) {return type == MOD_TYPE_MPT ? 65534 : 0xFE;}
 
-PATTERNINDEX COrderToPatternTable::GetInvalidPatIndex() const {return GetInvalidPatIndex(m_rSndFile.GetType());}
-PATTERNINDEX COrderToPatternTable::GetIgnoreIndex() const {return GetIgnoreIndex(m_rSndFile.GetType());}
+ModSequence& ModSequence::operator=(const ModSequence& seq)
+//---------------------------------------------------------
+{
+	if (&seq == this)
+		return *this;
+	m_nIgnoreIndex = seq.m_nIgnoreIndex;
+	m_nInvalidIndex = seq.m_nInvalidIndex;
+	resize(seq.GetLength());
+	ArrayCopy(begin(), seq.begin(), m_nSize);
+	m_sName = seq.m_sName;
+	return *this;
+}
 
 
-void ReadModSequence(std::istream& iStrm, COrderToPatternTable& seq, const size_t)
-//--------------------------------------------------------------------------------
+
+/////////////////////////////////////
+// ModSequenceSet
+/////////////////////////////////////
+
+
+ModSequenceSet::ModSequenceSet(const CSoundFile& sndFile)
+	: ModSequence(sndFile, m_Cache, s_nCacheSize, s_nCacheSize, NoArrayDelete),
+	  m_nCurrentSeq(0)
+//-------------------------------------------------------------------
 {
+	m_Sequences.push_back(ModSequence(sndFile, s_nCacheSize));
+}
+
+
+const ModSequence& ModSequenceSet::GetSequence(SEQUENCEINDEX nSeq)
+//----------------------------------------------------------------
+{
+	if (nSeq == GetCurrentSequenceIndex())
+		CopyCacheToStorage();
+	return m_Sequences[nSeq];
+}
+
+
+void ModSequenceSet::CopyCacheToStorage()
+//---------------------------------------
+{
+	m_Sequences[m_nCurrentSeq] = *this;
+}
+
+
+void ModSequenceSet::CopyStorageToCache()
+//---------------------------------------
+{
+	const ModSequence& rSeq = m_Sequences[m_nCurrentSeq];
+	if (rSeq.GetLength() <= s_nCacheSize)
+	{
+		PATTERNINDEX* pOld = m_pArray;
+		m_pArray = m_Cache;
+		m_nSize = rSeq.GetLength();
+		m_nCapacity = s_nCacheSize;
+		m_sName = rSeq.m_sName;
+		ArrayCopy(m_pArray, rSeq.m_pArray, m_nSize);
+		if (m_bDeletableArray)
+			delete[] pOld;
+		m_bDeletableArray = false;
+	}
+	else
+		ModSequence::operator=(rSeq);
+}
+
+
+void ModSequenceSet::SetSequence(SEQUENCEINDEX n)
+//-----------------------------------------------
+{
+	CopyCacheToStorage();
+	m_nCurrentSeq = n;
+	CopyStorageToCache();
+}
+
+
+void ModSequenceSet::AddSequence(bool bDuplicate)
+//-----------------------------------------------
+{
+	m_Sequences.push_back(ModSequence(*m_pSndFile, s_nCacheSize)); 
+	if (bDuplicate)
+	{
+		m_Sequences.back() = *this;
+		m_Sequences.back().m_sName = ""; // Don't copy sequence name.
+	}
+	SetSequence(GetNumSequences() - 1);
+}
+
+
+void ModSequenceSet::RemoveSequence(SEQUENCEINDEX i)
+//--------------------------------------------------
+{
+	// Do nothing if index is invalid or if there's only one sequence left.
+	if (i >= m_Sequences.size() || m_Sequences.size() <= 1) 
+		return;
+	const bool bSequenceChanges = (i == m_nCurrentSeq);
+	m_Sequences.erase(m_Sequences.begin() + i);
+	if (i < m_nCurrentSeq || m_nCurrentSeq >= GetNumSequences())
+		m_nCurrentSeq--;
+	if (bSequenceChanges)
+		CopyStorageToCache();
+}
+
+
+/////////////////////////////////////
+// Read/Write
+/////////////////////////////////////
+
+
+DWORD ModSequence::Deserialize(const BYTE* const src, const DWORD memLength)
+//--------------------------------------------------------------------------
+{
+	if(memLength < 2 + 4) return 0;
+	uint16 version = 0;
+	uint16 s = 0;
+	DWORD memPos = 0;
+	memcpy(&version, src, sizeof(version));
+	memPos += sizeof(version);
+	if(version != 0) return memPos;
+    memcpy(&s, src+memPos, sizeof(s));
+	memPos += 4;
+	if(s > 65000) return true;
+	if(memLength < memPos+s*4) return memPos;
+
+	const uint16 nOriginalSize = s;
+	LimitMax(s, ModSpecs::mptm.ordersMax);
+
+	resize(max(s, MAX_ORDERS));
+	for(size_t i = 0; i<s; i++, memPos +=4 )
+	{
+		uint32 temp;
+		memcpy(&temp, src+memPos, 4);
+		(*this)[i] = static_cast<PATTERNINDEX>(temp);
+	}
+	memPos += 4*(nOriginalSize - s);
+	return memPos;
+}
+
+
+size_t ModSequence::WriteToByteArray(BYTE* dest, const UINT numOfBytes, const UINT destSize)
+//-----------------------------------------------------------------------------
+{
+	if(numOfBytes > destSize || numOfBytes > MAX_ORDERS) return true;
+	if(GetLength() < numOfBytes) resize(ORDERINDEX(numOfBytes), 0xFF);
+	UINT i = 0;
+	for(i = 0; i<numOfBytes; i++)
+	{
+		dest[i] = static_cast<BYTE>((*this)[i]);
+	}
+	return i; //Returns the number of bytes written.
+}
+
+
+size_t ModSequence::WriteAsByte(FILE* f, const uint16 count)
+//----------------------------------------------------------
+{
+	if(GetLength() < count) resize(count);
+
+	size_t i = 0;
+	
+	for(i = 0; i<count; i++)
+	{
+		const PATTERNINDEX pat = (*this)[i];
+		BYTE temp = static_cast<BYTE>((*this)[i]);
+
+		if(pat > 0xFD)
+		{
+			if(pat == GetInvalidPatIndex()) temp = 0xFF;
+			else temp = 0xFE;
+		}
+		fwrite(&temp, 1, 1, f);
+	}
+	return i; //Returns the number of bytes written.
+}
+
+
+bool ModSequence::ReadAsByte(const BYTE* pFrom, const int howMany, const int memLength)
+//-------------------------------------------------------------------------------------
+{
+	if(howMany < 0 || howMany > memLength) return true;
+	if(m_pSndFile->GetType() != MOD_TYPE_MPT && howMany > MAX_ORDERS) return true;
+	
+	if(GetLength() < static_cast<size_t>(howMany))
+		resize(ORDERINDEX(howMany));
+	
+	for(int i = 0; i<howMany; i++, pFrom++)
+		(*this)[i] = *pFrom;
+	return false;
+}
+
+
+void ReadModSequenceOld(std::istream& iStrm, ModSequenceSet& seq, const size_t)
+//-----------------------------------------------------------------------------
+{
 	uint16 size;
 	srlztn::Binaryread<uint16>(iStrm, size);
 	if(size > ModSpecs::mptm.ordersMax)
@@ -193,7 +378,7 @@
 		AfxMessageBox(str, MB_ICONWARNING);
 		size = ModSpecs::mptm.ordersMax;
 	}
-	seq.resize(max(size, MAX_ORDERS), seq.GetInvalidPatIndex());
+	seq.resize(max(size, MAX_ORDERS));
 	if(size == 0)
 		{ seq.Init(); return; }
 
@@ -206,16 +391,91 @@
 }
 
 
-void WriteModSequence(std::ostream& oStrm, const COrderToPatternTable& seq)
+void WriteModSequenceOld(std::ostream& oStrm, const ModSequenceSet& seq)
 //-------------------------------------------------------------------------
 {
-	uint16 size = seq.GetCount();
+	const uint16 size = seq.GetLength();
 	srlztn::Binarywrite<uint16>(oStrm, size);
-	const COrderToPatternTable::const_iterator endIter = seq.end();
-	for(COrderToPatternTable::const_iterator citer = seq.begin(); citer != endIter; citer++)
+	const ModSequenceSet::const_iterator endIter = seq.end();
+	for(ModSequenceSet::const_iterator citer = seq.begin(); citer != endIter; citer++)
 	{
 		const uint16 temp = static_cast<uint16>(*citer);
 		srlztn::Binarywrite<uint16>(oStrm, temp);
 	}
 }
 
+
+void WriteModSequence(std::ostream& oStrm, const ModSequence& seq)
+//----------------------------------------------------------------
+{
+	srlztn::Ssb ssb(oStrm);
+	ssb.BeginWrite(FileIdSequence, MptVersion::num);
+	ssb.WriteItem((LPCSTR)seq.m_sName, "n");
+	const uint16 nLength = seq.GetLengthTailTrimmed();
+	ssb.WriteItem<uint16>(nLength, "l");
+	ssb.WriteItem(seq.m_pArray, "a", 1, srlztn::ArrayWriter<uint16>(nLength));
+	ssb.FinishWrite();
+}
+
+
+void ReadModSequence(std::istream& iStrm, ModSequence& seq, const size_t)
+//-----------------------------------------------------------------------
+{
+	srlztn::Ssb ssb(iStrm);
+	ssb.BeginRead(FileIdSequence, MptVersion::num);
+	if ((ssb.m_Status & srlztn::SNT_FAILURE) != 0)
+		return;
+	std::string str;
+	ssb.ReadItem(str, "n");
+	seq.m_sName = str.c_str();
+	uint16 nSize = MAX_ORDERS;
+	ssb.ReadItem<uint16>(nSize, "l");
+	LimitMax(nSize, ModSpecs::mptm.ordersMax);
+	seq.resize(max(nSize, ModSequenceSet::s_nCacheSize));
+	ssb.ReadItem(seq.m_pArray, "a", 1, srlztn::ArrayReader<uint16>(nSize));
+}
+
+
+void WriteModSequences(std::ostream& oStrm, const ModSequenceSet& seq)
+//--------------------------------------------------------------------
+{
+	srlztn::Ssb ssb(oStrm);
+	ssb.BeginWrite(FileIdSequences, MptVersion::num);
+	const uint8 nSeqs = seq.GetNumSequences();
+	const uint8 nCurrent = seq.GetCurrentSequenceIndex();
+	ssb.WriteItem(nSeqs, "n");
+	ssb.WriteItem(nCurrent, "c");
+	for(uint8 i = 0; i < nSeqs; i++)
+	{
+		if (i == seq.GetCurrentSequenceIndex())
+			ssb.WriteItem(seq, &i, sizeof(i), &WriteModSequence);
+		else
+			ssb.WriteItem(seq.m_Sequences[i], &i, sizeof(i), &WriteModSequence);
+	}
+	ssb.FinishWrite();
+}
+
+
+void ReadModSequences(std::istream& iStrm, ModSequenceSet& seq, const size_t)
+//---------------------------------------------------------------------------
+{
+	srlztn::Ssb ssb(iStrm);
+	ssb.BeginRead(FileIdSequences, MptVersion::num);
+	if ((ssb.m_Status & srlztn::SNT_FAILURE) != 0)
+		return;
+	uint8 nSeqs;
+	uint8 nCurrent;
+	ssb.ReadItem(nSeqs, "n");
+	if (nSeqs == 0)
+		return;
+	LimitMax(nSeqs, MAX_SEQUENCES);
+	ssb.ReadItem(nCurrent, "c");
+	if (seq.GetNumSequences() < nSeqs)
+		seq.m_Sequences.resize(nSeqs, ModSequence(*seq.m_pSndFile, seq.s_nCacheSize));
+
+	for(uint8 i = 0; i < nSeqs; i++)
+		ssb.ReadItem(seq.m_Sequences[i], &i, sizeof(i), &ReadModSequence);
+	seq.m_nCurrentSeq = (nCurrent < seq.GetNumSequences()) ? nCurrent : 0;
+	seq.CopyStorageToCache();
+}
+

Modified: trunk/OpenMPT/soundlib/ModSequence.h
===================================================================
--- trunk/OpenMPT/soundlib/ModSequence.h	2009-09-15 22:10:35 UTC (rev 365)
+++ trunk/OpenMPT/soundlib/ModSequence.h	2009-09-16 19:05:00 UTC (rev 366)
@@ -1,68 +1,160 @@
-#ifndef ORDERTOPATTERNTABLE_H
-#define ORDERTOPATTERNTABLE_H
+#ifndef MOD_SEQUENCE_H
+#define MOD_SEQUENCE_H
 
 #include <vector>
-using std::vector;
 
 class CSoundFile;
+class ModSequenceSet;
 
-
-#pragma warning(disable:4244) //conversion from 'type1' to 'type2', possible loss of data.
-
-
-//==============================================
-class COrderToPatternTable : public vector<PATTERNINDEX>
-//==============================================
+class ModSequence
+//===============
 {
 public:
-	COrderToPatternTable(const CSoundFile& sndFile) : m_rSndFile(sndFile) {}
+	friend class ModSequenceSet;
+	typedef PATTERNINDEX* iterator;
+	typedef const PATTERNINDEX* const_iterator;
+	
+	friend void WriteModSequence(std::ostream& oStrm, const ModSequence& seq);
+	friend void ReadModSequence(std::istream& iStrm, ModSequence& seq, const size_t);
 
+	virtual ~ModSequence() {if (m_bDeletableArray) delete[] m_pArray;}
+	ModSequence(const ModSequence&);
+	ModSequence(const CSoundFile& rSf, ORDERINDEX nSize);
+	ModSequence(const CSoundFile& rSf, PATTERNINDEX* pArray, ORDERINDEX nSize, ORDERINDEX nCapacity, bool bDeletableArray);
+
 	// Initialize default sized sequence.
 	void Init();
 
-	bool ReadAsByte(const BYTE* pFrom, const int howMany, const int memLength);
+	PATTERNINDEX& operator[](const size_t i) {ASSERT(i < m_nSize); return m_pArray[i];}
+	const PATTERNINDEX& operator[](const size_t i) const {ASSERT(i < m_nSize); return m_pArray[i];}
 
-	size_t WriteAsByte(FILE* f, const UINT count);
+	PATTERNINDEX& Last() {ASSERT(m_nSize > 0); return m_pArray[m_nSize-1];}
+	const PATTERNINDEX& L...
 
[truncated message content]

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

From: <sag...@us...> - 2009-09-15 22:10:56

Revision: 365
          http://modplug.svn.sourceforge.net/modplug/?rev=365&view=rev
Author:   saga-games
Date:     2009-09-15 22:10:35 +0000 (Tue, 15 Sep 2009)

Log Message:
-----------
[New] Shareable color schemes (via config dialog)
[Fix] Instrument tab: Pitch/Pan input field allows negative values

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/Moptions.cpp
    trunk/OpenMPT/mptrack/Moptions.h
    trunk/OpenMPT/mptrack/mptrack.rc
    trunk/OpenMPT/mptrack/resource.h

Modified: trunk/OpenMPT/mptrack/Moptions.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Moptions.cpp	2009-09-15 17:15:29 UTC (rev 364)
+++ trunk/OpenMPT/mptrack/Moptions.cpp	2009-09-15 22:10:35 UTC (rev 365)
@@ -117,21 +117,23 @@
 
 BEGIN_MESSAGE_MAP(COptionsColors, CPropertyPage)
 	ON_WM_DRAWITEM()
-	ON_CBN_SELCHANGE(IDC_COMBO1,	OnColorSelChanged)
-	ON_EN_CHANGE(IDC_PRIMARYHILITE,OnSettingsChanged)
+	ON_CBN_SELCHANGE(IDC_COMBO1,		OnColorSelChanged)
+	ON_EN_CHANGE(IDC_PRIMARYHILITE,		OnSettingsChanged)
 	ON_EN_CHANGE(IDC_SECONDARYHILITE,	OnSettingsChanged)
-	ON_COMMAND(IDC_BUTTON1,			OnSelectColor1)
-	ON_COMMAND(IDC_BUTTON2,			OnSelectColor2)
-	ON_COMMAND(IDC_BUTTON3,			OnSelectColor3)
-	ON_COMMAND(IDC_BUTTON5,			OnPresetMPT)
-	ON_COMMAND(IDC_BUTTON6,			OnPresetFT2)
-	ON_COMMAND(IDC_BUTTON7,			OnPresetIT)
-	ON_COMMAND(IDC_BUTTON8,			OnPresetBuzz)
-	ON_COMMAND(IDC_CHECK1,			OnSettingsChanged)
-	ON_COMMAND(IDC_CHECK2,			OnPreviewChanged)
-	ON_COMMAND(IDC_CHECK3,			OnSettingsChanged)
-	ON_COMMAND(IDC_CHECK4,			OnPreviewChanged)
-	ON_COMMAND(IDC_CHECK5,			OnHiliteTimeSigsChanged)
+	ON_COMMAND(IDC_BUTTON1,				OnSelectColor1)
+	ON_COMMAND(IDC_BUTTON2,				OnSelectColor2)
+	ON_COMMAND(IDC_BUTTON3,				OnSelectColor3)
+	ON_COMMAND(IDC_BUTTON5,				OnPresetMPT)
+	ON_COMMAND(IDC_BUTTON6,				OnPresetFT2)
+	ON_COMMAND(IDC_BUTTON7,				OnPresetIT)
+	ON_COMMAND(IDC_BUTTON8,				OnPresetBuzz)
+	ON_COMMAND(IDC_LOAD_COLORSCHEME,	OnLoadColorScheme)
+	ON_COMMAND(IDC_SAVE_COLORSCHEME,	OnSaveColorScheme)
+	ON_COMMAND(IDC_CHECK1,				OnSettingsChanged)
+	ON_COMMAND(IDC_CHECK2,				OnPreviewChanged)
+	ON_COMMAND(IDC_CHECK3,				OnSettingsChanged)
+	ON_COMMAND(IDC_CHECK4,				OnPreviewChanged)
+	ON_COMMAND(IDC_CHECK5,				OnHiliteTimeSigsChanged)
 END_MESSAGE_MAP()
 
 
@@ -538,7 +540,7 @@
 	CustomColors[MODCOLOR_TEXTCURROW] = 0x00000000;
 	CustomColors[MODCOLOR_BACKSELECTED] = 0x00000000;
 	CustomColors[MODCOLOR_TEXTSELECTED] = 0x00ccd7dd;
-	//CustomColors[MODCOLOR_SAMPLE] = 0x0000ff00;
+	CustomColors[MODCOLOR_SAMPLE] = 0x0000ff00;
 	CustomColors[MODCOLOR_BACKPLAYCURSOR] = 0x007a99a9;
 	CustomColors[MODCOLOR_TEXTPLAYCURSOR] = 0x00000000;
 	CustomColors[MODCOLOR_BACKHILIGHT] = 0x00b5c5ce;
@@ -548,10 +550,54 @@
 	CustomColors[MODCOLOR_PANNING] = 0x00686800;
 	CustomColors[MODCOLOR_PITCH] = 0x00006262;
 	CustomColors[MODCOLOR_GLOBALS] = 0x00000066;
-	//CustomColors[MODCOLOR_ENVELOPES] = 0x000000ff;
+	CustomColors[MODCOLOR_ENVELOPES] = 0x000000ff;
 	OnPreviewChanged();
 }
 
+void COptionsColors::OnLoadColorScheme()
+//--------------------------------------
+{
+	CFileDialog dlg(TRUE, NULL, NULL,
+		OFN_ENABLESIZING | OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST,
+		"OpenMPT Color Schemes|*.mptcolor|"
+		"All Files (*.*)|*.*||",
+		this);
+	if (dlg.DoModal() != IDOK) return;
+
+	
+	TCHAR sFilename[MAX_PATH];
+	strcpy(sFilename, dlg.GetPathName());
+
+	for(int i = 0; i < MAX_MODCOLORS; i++)
+	{
+		TCHAR sKeyName[16];
+		wsprintf(sKeyName, "Color%02d", i);
+		CustomColors[i] = CMainFrame::GetPrivateProfileLong("Colors", sKeyName, CustomColors[i], sFilename);
+	}
+	OnPreviewChanged();
+}
+
+void COptionsColors::OnSaveColorScheme()
+//--------------------------------------
+{
+	CFileDialog dlg(FALSE, "mptcolor", NULL,
+		OFN_HIDEREADONLY| OFN_ENABLESIZING | OFN_OVERWRITEPROMPT | OFN_PATHMUSTEXIST | OFN_NOREADONLYRETURN,
+		"OpenMPT Color Schemes|*.mptcolor|",
+		this);
+	if (dlg.DoModal() != IDOK) return;
+
+	TCHAR sFilename[MAX_PATH];
+	strcpy(sFilename, dlg.GetPathName());
+
+	for(int i = 0; i < MAX_MODCOLORS; i++)
+	{
+		TCHAR sKeyName[16];
+		wsprintf(sKeyName, "Color%02d", i);
+		CMainFrame::WritePrivateProfileLong("Colors", sKeyName, CustomColors[i], sFilename);
+	}
+}
+
+
 /////////////////////////////////////////////////////////////////////////////////
 // COptionsGeneral
 

Modified: trunk/OpenMPT/mptrack/Moptions.h
===================================================================
--- trunk/OpenMPT/mptrack/Moptions.h	2009-09-15 17:15:29 UTC (rev 364)
+++ trunk/OpenMPT/mptrack/Moptions.h	2009-09-15 22:10:35 UTC (rev 365)
@@ -81,6 +81,8 @@
 	afx_msg void OnPresetFT2();
 	afx_msg void OnPresetIT();
 	afx_msg void OnPresetBuzz();
+	afx_msg void OnLoadColorScheme();
+	afx_msg void OnSaveColorScheme();
 	afx_msg void OnPreviewChanged();
 	DECLARE_MESSAGE_MAP();
 };

Modified: trunk/OpenMPT/mptrack/mptrack.rc
===================================================================
--- trunk/OpenMPT/mptrack/mptrack.rc	2009-09-15 17:15:29 UTC (rev 364)
+++ trunk/OpenMPT/mptrack/mptrack.rc	2009-09-15 22:10:35 UTC (rev 365)
@@ -210,7 +210,7 @@
     PUSHBUTTON      "Clear Log",IDC_CLEARLOG,227,85,37,9
 END
 
-IDD_OPTIONS_COLORS DIALOGEX 0, 0, 272, 231
+IDD_OPTIONS_COLORS DIALOGEX 0, 0, 272, 281
 STYLE DS_SETFONT | DS_3DLOOK | WS_CHILD | WS_DISABLED | WS_CAPTION
 CAPTION "Colors"
 FONT 8, "MS Sans Serif", 0, 0, 0x0
@@ -222,24 +222,26 @@
     EDITTEXT        IDC_SECONDARYHILITE,114,108,21,12,ES_AUTOHSCROLL | ES_NUMBER
     CONTROL         "Enable effect highlighting",IDC_CHECK2,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,15,60,114,10
     CONTROL         "Use small font",IDC_CHECK3,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,15,45,102,10
-    PUSHBUTTON      "MPT",IDC_BUTTON5,159,26,22,12
-    PUSHBUTTON      "FT2",IDC_BUTTON6,185,26,22,12
-    PUSHBUTTON      "IT",IDC_BUTTON7,210,25,22,12
-    PUSHBUTTON      "Buzz",IDC_BUTTON8,235,25,22,12
+    PUSHBUTTON      "MPT",IDC_BUTTON5,144,246,24,15
+    PUSHBUTTON      "FT2",IDC_BUTTON6,204,246,24,15
+    PUSHBUTTON      "IT",IDC_BUTTON7,174,246,24,15
+    PUSHBUTTON      "Buzz",IDC_BUTTON8,234,246,24,15
     CONTROL         "Color",IDC_BUTTON1,"Button",BS_OWNERDRAW,25,194,51,15
     CONTROL         "Color",IDC_BUTTON2,"Button",BS_OWNERDRAW,98,194,51,15
     CONTROL         "Color",IDC_BUTTON3,"Button",BS_OWNERDRAW,168,194,51,15
     LTEXT           "Background:",IDC_TEXT1,25,183,60,8
     LTEXT           "Foreground:",IDC_TEXT2,98,183,62,8
     LTEXT           "Highlight:",IDC_TEXT3,169,185,61,8
-    GROUPBOX        "",IDC_STATIC,5,5,260,220
+    GROUPBOX        "",IDC_STATIC,5,5,260,211
     LTEXT           "Select color for:",IDC_STATIC,15,15,63,8
     LTEXT           "rows",IDC_STATIC,138,92,16,8
-    LTEXT           "Presets:",IDC_STATIC,159,15,28,8
     LTEXT           "rows",IDC_STATIC,138,110,16,8
     CONTROL         "",IDC_BUTTON4,"Button",BS_OWNERDRAW | BS_FLAT,65,130,114,43
     CONTROL         "Set highlights to songs' time signatures",IDC_CHECK5,
                     "Button",BS_AUTOCHECKBOX | WS_TABSTOP,15,75,136,10
+    PUSHBUTTON      "Load...",IDC_LOAD_COLORSCHEME,18,246,48,15
+    PUSHBUTTON      "Save...",IDC_SAVE_COLORSCHEME,72,246,48,15
+    GROUPBOX        "Color Presets",IDC_STATIC,6,228,264,42
 END
 
 IDD_OPTIONS_MIDI DIALOGEX 0, 0, 272, 281
@@ -478,7 +480,7 @@
     CONTROL         "Pan",IDC_CHECK1,"Button",BS_AUTOCHECKBOX | BS_FLAT | WS_TABSTOP,55,71,29,10
     EDITTEXT        IDC_EDIT9,87,70,34,12,ES_NUMBER
     CONTROL         "Spin1",IDC_SPIN9,"msctls_updown32",UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | UDS_NOTHOUSANDS,112,74,8,11
-    EDITTEXT        IDC_EDIT15,33,99,27,13,ES_NUMBER
+    EDITTEXT        IDC_EDIT15,33,99,27,13
     CONTROL         "Spin1",IDC_SPIN12,"msctls_updown32",UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | UDS_NOTHOUSANDS,61,103,7,11
     COMBOBOX        IDC_COMBO4,95,99,27,91,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP
     CONTROL         "",IDC_SLIDER5,"msctls_trackbar32",TBS_BOTH | TBS_NOTICKS,47,135,36,10
@@ -1399,7 +1401,7 @@
     IDD_OPTIONS_COLORS, DIALOG
     BEGIN
         RIGHTMARGIN, 247
-        BOTTOMMARGIN, 151
+        BOTTOMMARGIN, 201
     END
 
     IDD_OPTIONS_MIDI, DIALOG

Modified: trunk/OpenMPT/mptrack/resource.h
===================================================================
--- trunk/OpenMPT/mptrack/resource.h	2009-09-15 17:15:29 UTC (rev 364)
+++ trunk/OpenMPT/mptrack/resource.h	2009-09-15 22:10:35 UTC (rev 365)
@@ -883,6 +883,8 @@
 #define IDC_RADIO_RESIZETO              2384
 #define IDC_EDIT_MODLOADING_WARNINGS    2385
 #define IDC_CHECK_PATRECORD             2386
+#define IDC_LOAD_COLORSCHEME            2387
+#define IDC_SAVE_COLORSCHEME            2388
 #define ID_FILE_NEWMOD                  32771
 #define ID_FILE_NEWXM                   32772
 #define ID_FILE_NEWS3M                  32773
@@ -1116,7 +1118,7 @@
 #define ID_OVERFLOWPASTE                59226
 #define ID_NOTEMAP_COPY_NOTE            59227
 #define ID_CLEANUP_REARRANGESAMPLES     59228
-#define ID_ORDERLIST_RENDER				59229
+#define ID_ORDERLIST_RENDER             59229
 
 // Next default values for new objects
 // 
@@ -1125,7 +1127,7 @@
 #define _APS_3D_CONTROLS                     1
 #define _APS_NEXT_RESOURCE_VALUE        521
 #define _APS_NEXT_COMMAND_VALUE         59230
-#define _APS_NEXT_CONTROL_VALUE         2387
+#define _APS_NEXT_CONTROL_VALUE         2389
 #define _APS_NEXT_SYMED_VALUE           901
 #endif
 #endif


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-09-15 17:15:39

Revision: 364
          http://modplug.svn.sourceforge.net/modplug/?rev=364&view=rev
Author:   saga-games
Date:     2009-09-15 17:15:29 +0000 (Tue, 15 Sep 2009)

Log Message:
-----------
[Fix] Wave Export: Order mode was always enabled by default.
[Fix] IT Compatibility: Special case of Retrigger + Envelopes
[Fix] Instrument / Sample tab: Remove special chars from sample filenames so the "save as" dialog will show up on OSs < Vista
[Mod] Instrument tab: Also show values from 0 to 64 for filter envelope (instead of -32 to 32)
[Imp] Macro Config: Also show the current preset for Zxx config (Z80 - ZFF)
[Ref] Changed some BOOLs into bools, usage of *INDEX types

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/Ctrl_ins.cpp
    trunk/OpenMPT/mptrack/Ctrl_smp.cpp
    trunk/OpenMPT/mptrack/Moddoc.cpp
    trunk/OpenMPT/mptrack/Moddoc.h
    trunk/OpenMPT/mptrack/Modedit.cpp
    trunk/OpenMPT/mptrack/View_ins.cpp
    trunk/OpenMPT/mptrack/View_pat.cpp
    trunk/OpenMPT/mptrack/dlg_misc.cpp
    trunk/OpenMPT/mptrack/misc_util.h
    trunk/OpenMPT/mptrack/mod2midi.cpp
    trunk/OpenMPT/soundlib/Sampleio.cpp
    trunk/OpenMPT/soundlib/Snd_fx.cpp
    trunk/OpenMPT/soundlib/Sndfile.cpp
    trunk/OpenMPT/soundlib/Sndfile.h

Modified: trunk/OpenMPT/mptrack/Ctrl_ins.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_ins.cpp	2009-09-13 20:41:27 UTC (rev 363)
+++ trunk/OpenMPT/mptrack/Ctrl_ins.cpp	2009-09-15 17:15:29 UTC (rev 364)
@@ -1603,7 +1603,7 @@
 void CCtrlInstruments::OnInstrumentSave()
 //---------------------------------------
 {
-	CHAR szFileName[_MAX_PATH] = "", drive[_MAX_DRIVE], path[_MAX_PATH], ext[_MAX_EXT];
+	TCHAR szFileName[_MAX_PATH] = "", drive[_MAX_DRIVE], path[_MAX_PATH], ext[_MAX_EXT];
 	MODINSTRUMENT *pIns = m_pSndFile->Instruments[m_nInstrument];
 	
 	if (!pIns) return;
@@ -1616,6 +1616,8 @@
 		memcpy(szFileName, pIns->name, 22);
 		szFileName[22] = 0;
 	}
+	SanitizeFilename(szFileName);
+
 // -> CODE#0019
 // -> DESC="correctly load ITI & XI instruments sample note map"
 //	CFileDialog dlg(FALSE, (m_pSndFile->m_nType & MOD_TYPE_IT) ? "iti" : "xi",

Modified: trunk/OpenMPT/mptrack/Ctrl_smp.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_smp.cpp	2009-09-13 20:41:27 UTC (rev 363)
+++ trunk/OpenMPT/mptrack/Ctrl_smp.cpp	2009-09-15 17:15:29 UTC (rev 364)
@@ -975,8 +975,8 @@
 {
 	if(!m_pSndFile) return;
 
-	CHAR szFileName[_MAX_PATH] = "";
-	BOOL bBatchSave = CMainFrame::GetInputHandler()->ShiftPressed();
+	TCHAR szFileName[_MAX_PATH];
+	bool bBatchSave = CMainFrame::GetInputHandler()->ShiftPressed();
 
 	if(!bBatchSave)
 	{
@@ -993,8 +993,7 @@
 		} else
 		{
 			memcpy(szFileName, m_pSndFile->m_szNames[m_nSample], 32);
-			szFileName[32] = 0;
-		}
+			szFileName[32] = 0;		}
 		if (!szFileName[0]) strcpy(szFileName, "untitled");
 	}
 	else
@@ -1011,6 +1010,7 @@
 		sPath += ".wav";
 		_splitpath(sPath, NULL, NULL, szFileName, NULL);
 	}
+	SanitizeFilename(szFileName);
 
 	CFileDialog dlg(FALSE, "wav",
 			szFileName,
@@ -1027,7 +1027,7 @@
 	TCHAR ext[_MAX_EXT];
 	_splitpath(dlg.GetPathName(), NULL, NULL, NULL, ext);
 
-	BOOL bOk = FALSE;
+	bool bOk = false;
 	UINT iMinSmp = m_nSample, iMaxSmp = m_nSample;
 	CString sFilename = dlg.GetPathName(), sNumberFormat;
 	if(bBatchSave)
@@ -1037,24 +1037,20 @@
 		sNumberFormat.Format("%s%d%s", "%.", ((int)log10((float)iMaxSmp)) + 1, "d");
 	}
 
-	const CString sForbiddenChars = "\\/:\"?<>*";
-
 	for(UINT iSmp = iMinSmp; iSmp <= iMaxSmp; iSmp++)
 	{
 		if (m_pSndFile->Samples[iSmp].pSample)
 		{
 			if(bBatchSave)
 			{
-				CString sSampleNumber, sSampleName, sSampleFilename;
+				CString sSampleNumber;
+				TCHAR sSampleName[64], sSampleFilename[64];
 				sSampleNumber.Format(sNumberFormat, iSmp);
 
-				sSampleName = (m_pSndFile->m_szNames[iSmp]) ? m_pSndFile->m_szNames[iSmp] : "untitled";
-				sSampleFilename = (m_pSndFile->Samples[iSmp].filename[0]) ? m_pSndFile->Samples[iSmp].filename : m_pSndFile->m_szNames[iSmp];
-				for(UINT i = 0; i < sForbiddenChars.GetLength(); i++)
-				{
-					sSampleName.Remove(sForbiddenChars.GetAt(i));
-					sSampleFilename.Remove(sForbiddenChars.GetAt(i));
-				}
+				strcpy(sSampleName, (m_pSndFile->m_szNames[iSmp]) ? m_pSndFile->m_szNames[iSmp] : "untitled");
+				strcpy(sSampleFilename, (m_pSndFile->Samples[iSmp].filename[0]) ? m_pSndFile->Samples[iSmp].filename : m_pSndFile->m_szNames[iSmp]);
+				SanitizeFilename(sSampleName);
+				SanitizeFilename(sSampleFilename);
 
 				sFilename = dlg.GetPathName();
 				sFilename.Replace("%sample_number%", sSampleNumber);

Modified: trunk/OpenMPT/mptrack/Moddoc.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Moddoc.cpp	2009-09-13 20:41:27 UTC (rev 363)
+++ trunk/OpenMPT/mptrack/Moddoc.cpp	2009-09-15 17:15:29 UTC (rev 364)
@@ -1388,7 +1388,7 @@
 void CModDoc::OnFileWaveConvert()
 //-------------------------------
 {
-	OnFileWaveConvert(0, 0);
+	OnFileWaveConvert(ORDERINDEX_INVALID, ORDERINDEX_INVALID);
 }
 
 void CModDoc::OnFileWaveConvert(ORDERINDEX nMinOrder, ORDERINDEX nMaxOrder)
@@ -2935,7 +2935,7 @@
 }
 
 HWND CModDoc::GetEditPosition(ROWINDEX &row, PATTERNINDEX &pat, ORDERINDEX &ord)
-//------------------------------------------------------------
+//------------------------------------------------------------------------------
 {
 	HWND followSonghWnd;
 	PATTERNVIEWSTATE *patternViewState;
@@ -2976,7 +2976,7 @@
 
 	//ensure order correlates with pattern.
 	if (pSndFile->Order[ord]!=pat) {
-		int tentativeOrder = pSndFile->FindOrder(pat);
+		ORDERINDEX tentativeOrder = pSndFile->FindOrder(pat);
 		if (tentativeOrder != -1) {	//ensure a valid order exists.
 			ord = tentativeOrder;
 		}
@@ -3041,7 +3041,68 @@
 	return -1;
 }
 
+// Retrieve Zxx (Z80-ZFF) type from current macro configuration
+int CModDoc::GetZxxType(const CHAR (&szMidiZXXExt)[128 * 32])
+//-----------------------------------------------------------
+{
+	// Compare with all possible preset patterns
+	for(int i = 1; i <= 5; i++)
+	{
+		// Prepare pattern to compare
+		CHAR szPatterns[128 * 32];
+		CreateZxxFromType(szPatterns, i);
 
+		bool bFound = true;
+		for(int j = 0; j < 128; j++)
+		{
+			if(strncmp(&szPatterns[j * 32], &szMidiZXXExt[j * 32], 32))
+				bFound = false;
+		}
+		if(bFound) return i;
+	}
+	return 0; // Type 0 - Custom setup
+}
+
+// Create Zxx (Z80 - ZFF) from one out of five presets
+void CModDoc::CreateZxxFromType(CHAR (&szMidiZXXExt)[128 * 32], int iZxxType)
+//---------------------------------------------------------------------------
+{
+	for(int i = 0; i < 128; i++)
+	{
+		switch(iZxxType)
+		{
+		case 1:
+			// Type 1 - Z80 - Z8F controls resonance
+			if (i < 16) wsprintf(&szMidiZXXExt[i * 32], "F0F001%02X", i * 8);
+			else szMidiZXXExt[i * 32] = 0;
+			break;
+
+		case 2:
+			// Type 2 - Z80 - ZFF controls resonance
+			wsprintf(&szMidiZXXExt[i * 32], "F0F001%02X", i);
+			break;
+
+		case 3:
+			// Type 3 - Z80 - ZFF controls cutoff
+			wsprintf(&szMidiZXXExt[i * 32], "F0F000%02X", i);
+			break;
+
+		case 4:
+			// Type 4 - Z80 - ZFF controls filter mode
+			wsprintf(&szMidiZXXExt[i * 32], "F0F002%02X", i);
+			break;
+
+		case 5:
+			// Type 5 - Z80 - Z9F controls resonance + filter mode
+			if (i < 16) wsprintf(&szMidiZXXExt[i * 32], "F0F001%02X", i * 8);
+			else if (i < 32) wsprintf(&szMidiZXXExt[i * 32], "F0F002%02X", (i - 16) * 8);
+			else szMidiZXXExt[i * 32] = 0;
+			break;
+		}
+	}
+}
+
+
 ////////////////////////////////////////////////////////////////////////////////////////
 // Playback
 

Modified: trunk/OpenMPT/mptrack/Moddoc.h
===================================================================
--- trunk/OpenMPT/mptrack/Moddoc.h	2009-09-13 20:41:27 UTC (rev 363)
+++ trunk/OpenMPT/mptrack/Moddoc.h	2009-09-15 17:15:29 UTC (rev 364)
@@ -181,6 +181,8 @@
 	int MacroToPlugParam(CString value); //rewbs.xinfo
 	int MacroToMidiCC(CString value);
 	int FindMacroForParam(long param);
+	int GetZxxType(const CHAR (&szMidiZXXExt)[128 * 32]);
+	void CreateZxxFromType(CHAR (&szMidiZXXExt)[128 * 32], int iZxxType);
 	void SongProperties();
 // operations
 public:

Modified: trunk/OpenMPT/mptrack/Modedit.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Modedit.cpp	2009-09-13 20:41:27 UTC (rev 363)
+++ trunk/OpenMPT/mptrack/Modedit.cpp	2009-09-15 17:15:29 UTC (rev 364)
@@ -1433,7 +1433,7 @@
 		}
 	}
 
-	for (UINT i=1; i<=m_SndFile.m_nInstruments; i++)
+	for (INSTRUMENTINDEX i = 1; i <= m_SndFile.m_nInstruments; i++)
 	{
 		m_SndFile.DestroyInstrument(i,removeSamples);
 	}
@@ -1453,7 +1453,7 @@
 	CHAR s[512];
 	UINT nRemoved = 0;
 	UINT nSwap, nIndex;
-	BOOL bReorg = FALSE;
+	bool bReorg = false;
 
 	if (!m_SndFile.m_nInstruments) return FALSE;
 
@@ -1469,7 +1469,7 @@
 	BeginWaitCursor();
 	memset(usedmap, 0, sizeof(usedmap));
 
-	for (UINT i=m_SndFile.m_nInstruments; i>=1; i--)
+	for(INSTRUMENTINDEX i = m_SndFile.m_nInstruments; i >= 1; i--)
 	{
 		if (!m_SndFile.IsInstrumentUsed(i))
 		{
@@ -1477,9 +1477,9 @@
 // -> CODE#0003
 // -> DESC="remove instrument's samples"
 //			m_SndFile.DestroyInstrument(i);
-			m_SndFile.DestroyInstrument(i,removeSamples);
+			m_SndFile.DestroyInstrument(i, removeSamples);
 // -! BEHAVIOUR_CHANGE#0003
-			if ((i == m_SndFile.m_nInstruments) && (i>1)) m_SndFile.m_nInstruments--; else bReorg = TRUE;
+			if ((i == m_SndFile.m_nInstruments) && (i>1)) m_SndFile.m_nInstruments--; else bReorg = true;
 			END_CRITICAL();
 			nRemoved++;
 		} else
@@ -1701,8 +1701,8 @@
 SAMPLEINDEX CModDoc::InsertSample(bool bLimit)
 //--------------------------------------------
 {
-	UINT i = 1;
-	for (i=1; i<=m_SndFile.m_nSamples; i++)
+	SAMPLEINDEX i = 1;
+	for(i = 1; i <= m_SndFile.m_nSamples; i++)
 	{
 		if ((!m_SndFile.m_szNames[i][0]) && (m_SndFile.Samples[i].pSample == NULL))
 		{
@@ -1802,7 +1802,7 @@
 		} else
 		if (!pDup)
 		{
-			for (UINT k=1; k<=m_SndFile.m_nSamples; k++)
+			for(SAMPLEINDEX k = 1; k <= m_SndFile.m_nSamples; k++)
 			{
 				if (!m_SndFile.IsSampleUsed(k))
 				{

Modified: trunk/OpenMPT/mptrack/View_ins.cpp
===================================================================
--- trunk/OpenMPT/mptrack/View_ins.cpp	2009-09-13 20:41:27 UTC (rev 363)
+++ trunk/OpenMPT/mptrack/View_ins.cpp	2009-09-15 17:15:29 UTC (rev 364)
@@ -1614,6 +1614,11 @@
 //------------------------------------------------
 {
 	CModDoc *pModDoc = GetDocument();
+	if(pModDoc == nullptr) return;
+	CSoundFile *pSndFile = pModDoc->GetSoundFile();
+	if(pSndFile == nullptr) return;
+	MODINSTRUMENT *pIns = pSndFile->Instruments[m_nInstrument];
+
 	BOOL bSplitCursor = FALSE;
 	CHAR s[256];
 
@@ -1632,7 +1637,7 @@
 	if (nVal > 64) nVal = 64;
 	if (nTick < 0) nTick = 0;
 	if (nTick <= EnvGetReleaseNodeTick() + 1 || EnvGetReleaseNode() == ENV_RELEASE_NODE_UNSET) {
-		int displayVal = (m_nEnv != ENV_VOLUME) ? nVal-32 : nVal;
+		int displayVal = (m_nEnv != ENV_VOLUME && !(m_nEnv == ENV_PITCH && (pIns->dwFlags & ENV_FILTER))) ? nVal - 32 : nVal;
 		wsprintf(s, "Tick %d, [%d]", nTick, displayVal);
 	} else {
 		int displayVal = (nVal - EnvGetReleaseNodeValue()) * 2;

Modified: trunk/OpenMPT/mptrack/View_pat.cpp
===================================================================
--- trunk/OpenMPT/mptrack/View_pat.cpp	2009-09-13 20:41:27 UTC (rev 363)
+++ trunk/OpenMPT/mptrack/View_pat.cpp	2009-09-15 17:15:29 UTC (rev 364)
@@ -3542,15 +3542,15 @@
 		case kcNextPattern:	{	UINT n = m_nPattern + 1;
             					while ((n < pSndFile->Patterns.Size()) && (!pSndFile->Patterns[n])) n++;
 								SetCurrentPattern((n < pSndFile->Patterns.Size()) ? n : 0);
-								int currentOrder = SendCtrlMessage(CTRLMSG_GETCURRENTORDER);
-								int newOrder = pSndFile->FindOrder(m_nPattern, currentOrder, true);
+								ORDERINDEX currentOrder = SendCtrlMessage(CTRLMSG_GETCURRENTORDER);
+								ORDERINDEX newOrder = pSndFile->FindOrder(m_nPattern, currentOrder, true);
 								SendCtrlMessage(CTRLMSG_SETCURRENTORDER, newOrder);
 								return wParam; }
 		case kcPrevPattern: {	UINT n = (m_nPattern) ? m_nPattern - 1 : pSndFile->Patterns.Size()-1;
 								while ((n > 0) && (!pSndFile->Patterns[n])) n--;
 								SetCurrentPattern(n);
-								int currentOrder = SendCtrlMessage(CTRLMSG_GETCURRENTORDER);
-								int newOrder = pSndFile->FindOrder(m_nPattern, currentOrder, false);
+								ORDERINDEX currentOrder = SendCtrlMessage(CTRLMSG_GETCURRENTORDER);
+								ORDERINDEX newOrder = pSndFile->FindOrder(m_nPattern, currentOrder, false);
 								SendCtrlMessage(CTRLMSG_SETCURRENTORDER, newOrder);
 								return wParam; }
 		case kcSelectWithCopySelect:

Modified: trunk/OpenMPT/mptrack/dlg_misc.cpp
===================================================================
--- trunk/OpenMPT/mptrack/dlg_misc.cpp	2009-09-13 20:41:27 UTC (rev 363)
+++ trunk/OpenMPT/mptrack/dlg_misc.cpp	2009-09-15 17:15:29 UTC (rev 364)
@@ -1799,6 +1799,11 @@
 BOOL CMidiMacroSetup::OnInitDialog()
 //----------------------------------
 {
+	m_pModDoc = CMainFrame::GetMainFrame()->GetActiveDoc();
+	if (m_pModDoc) m_pSndFile = CMainFrame::GetMainFrame()->GetActiveDoc()->GetSoundFile();
+	if (!m_pSndFile)
+		return FALSE;
+
 	CHAR s[128];
 	CDialog::OnInitDialog();
 	CheckDlgButton(IDC_CHECK1, m_bEmbed);
@@ -1837,7 +1842,7 @@
 	m_CbnZxxPreset.AddString("Z80-ZFF controls cutoff");
 	m_CbnZxxPreset.AddString("Z80-ZFF controls filter mode");
 	m_CbnZxxPreset.AddString("Z80-Z9F controls resonance+mode");
-	m_CbnZxxPreset.SetCurSel(0);
+	m_CbnZxxPreset.SetCurSel(m_pModDoc->GetZxxType(m_MidiCfg.szMidiZXXExt));
 	UpdateDialog();
 
 	int offsetx=108, offsety=30, separatorx=4, separatory=2, 
@@ -1863,10 +1868,6 @@
 	}
 	UpdateMacroList();
 
-	m_pModDoc = CMainFrame::GetMainFrame()->GetActiveDoc();
-	if (m_pModDoc) m_pSndFile = CMainFrame::GetMainFrame()->GetActiveDoc()->GetSoundFile();
-	if (!m_pSndFile)
-		return FALSE;
 	for (UINT plug=0; plug<MAX_MIXPLUGINS; plug++)
 	{
 		PSNDMIXPLUGIN p = &(m_pSndFile->m_MixPlugins[plug]);
@@ -2034,39 +2035,10 @@
 {
 	UINT zxx_preset = m_CbnZxxPreset.GetCurSel();
 
-	if (zxx_preset)
+	if (zxx_preset && m_pModDoc != nullptr)
 	{
-		BeginWaitCursor();
-		for (UINT i=0; i<128; i++)
-		{
-			switch(zxx_preset)
-			{
-			case 1:
-				if (i<16) wsprintf(&m_MidiCfg.szMidiZXXExt[i*32], "F0F001%02X", i*8);
-				else m_MidiCfg.szMidiZXXExt[i*32] = 0;
-				break;
-
-			case 2:
-				wsprintf(&m_MidiCfg.szMidiZXXExt[i*32], "F0F001%02X", i);
-				break;
-
-			case 3:
-				wsprintf(&m_MidiCfg.szMidiZXXExt[i*32], "F0F000%02X", i);
-				break;
-
-			case 4:
-				wsprintf(&m_MidiCfg.szMidiZXXExt[i*32], "F0F002%02X", i);
-				break;
-
-			case 5:
-				if (i<16) wsprintf(&m_MidiCfg.szMidiZXXExt[i*32], "F0F001%02X", i*8);
-				else if (i<32) wsprintf(&m_MidiCfg.szMidiZXXExt[i*32], "F0F002%02X", (i-16)*8);
-				else m_MidiCfg.szMidiZXXExt[i*32] = 0;
-				break;
-			}
-		}
+		m_pModDoc->CreateZxxFromType(m_MidiCfg.szMidiZXXExt, zxx_preset);
 		UpdateDialog();
-		EndWaitCursor();
 	}
 }
 

Modified: trunk/OpenMPT/mptrack/misc_util.h
===================================================================
--- trunk/OpenMPT/mptrack/misc_util.h	2009-09-13 20:41:27 UTC (rev 363)
+++ trunk/OpenMPT/mptrack/misc_util.h	2009-09-15 17:15:29 UTC (rev 364)
@@ -110,4 +110,29 @@
 	utilImpl::ArrayCopyImpl<std::tr1::has_trivial_assign<T>::value>::Do(pDst, pSrc, n);
 }
 
+// Sanitize a filename (remove special chars)
+template <size_t size>
+inline void SanitizeFilename(char (&buffer)[size])
+{
+	STATIC_ASSERT(size > 0);
+	for(int i = 0; i < size; i++)
+	{
+		if(	buffer[i] == '\\' ||
+			buffer[i] == '\"' ||
+			buffer[i] == '/'  ||
+			buffer[i] == ':'  ||
+			buffer[i] == '?'  ||
+			buffer[i] == '<'  ||
+			buffer[i] == '>'  ||
+			buffer[i] == '*')
+		{
+			for(int j = i + 1; j < size; j++)
+			{
+				buffer[j - 1] = buffer[j];
+			}
+			buffer[size - 1] = 0;
+		}
+	}
+}
+
 #endif

Modified: trunk/OpenMPT/mptrack/mod2midi.cpp
===================================================================
--- trunk/OpenMPT/mptrack/mod2midi.cpp	2009-09-13 20:41:27 UTC (rev 363)
+++ trunk/OpenMPT/mptrack/mod2midi.cpp	2009-09-15 17:15:29 UTC (rev 364)
@@ -167,7 +167,7 @@
 	m_nCurrInstr = 1;
 	if (m_pSndFile->m_nInstruments)
 	{
-		for (UINT nIns=1; nIns<=m_pSndFile->m_nInstruments; nIns++)
+		for(INSTRUMENTINDEX nIns = 1; nIns <= m_pSndFile->m_nInstruments; nIns++)
 		{
 			MODINSTRUMENT *pIns = m_pSndFile->Instruments[nIns];
 			if ((pIns) && (m_pSndFile->IsInstrumentUsed(nIns)))
@@ -180,15 +180,15 @@
 		}
 	} else
 	{
-		for (UINT nIns=1; nIns<=m_pSndFile->m_nSamples; nIns++)
+		for(SAMPLEINDEX nSmp = 1; nSmp <= m_pSndFile->m_nSamples; nSmp++)
 		{
-			if ((m_pSndFile->Samples[nIns].pSample)
-			 && (m_pSndFile->IsSampleUsed(nIns)))
+			if ((m_pSndFile->Samples[nSmp].pSample)
+			 && (m_pSndFile->IsSampleUsed(nSmp)))
 			{
 				memset(s, 0, sizeof(s));
-				wsprintf(s, "%02d: ", nIns);
-				memcpy(s+strlen(s), m_pSndFile->m_szNames[nIns], 32);
-				m_CbnInstrument.SetItemData(m_CbnInstrument.AddString(s), nIns);
+				wsprintf(s, "%02d: ", nSmp);
+				memcpy(s+strlen(s), m_pSndFile->m_szNames[nSmp], 32);
+				m_CbnInstrument.SetItemData(m_CbnInstrument.AddString(s), nSmp);
 			}
 		}
 	}

Modified: trunk/OpenMPT/soundlib/Sampleio.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Sampleio.cpp	2009-09-13 20:41:27 UTC (rev 363)
+++ trunk/OpenMPT/soundlib/Sampleio.cpp	2009-09-15 17:15:29 UTC (rev 364)
@@ -14,10 +14,10 @@
 
 #pragma warning(disable:4244)
 
-BOOL CSoundFile::ReadSampleFromFile(UINT nSample, LPBYTE lpMemFile, DWORD dwFileLength)
-//-------------------------------------------------------------------------------------
+bool CSoundFile::ReadSampleFromFile(SAMPLEINDEX nSample, LPBYTE lpMemFile, DWORD dwFileLength)
+//--------------------------------------------------------------------------------------------
 {
-	if ((!nSample) || (nSample >= MAX_SAMPLES)) return FALSE;
+	if ((!nSample) || (nSample >= MAX_SAMPLES)) return false;
 	if ((!ReadWAVSample(nSample, lpMemFile, dwFileLength))
 	 && (!ReadXISample(nSample, lpMemFile, dwFileLength))
 	 && (!ReadAIFFSample(nSample, lpMemFile, dwFileLength))
@@ -25,30 +25,30 @@
 	 && (!ReadPATSample(nSample, lpMemFile, dwFileLength))
 	 && (!Read8SVXSample(nSample, lpMemFile, dwFileLength))
 	 && (!ReadS3ISample(nSample, lpMemFile, dwFileLength)))
-		return FALSE;
-	return TRUE;
+		return false;
+	return true;
 }
 
 
-BOOL CSoundFile::ReadInstrumentFromFile(UINT nInstr, LPBYTE lpMemFile, DWORD dwFileLength)
-//----------------------------------------------------------------------------------------
+bool CSoundFile::ReadInstrumentFromFile(INSTRUMENTINDEX nInstr, LPBYTE lpMemFile, DWORD dwFileLength)
+//---------------------------------------------------------------------------------------------------
 {
-	if ((!nInstr) || (nInstr >= MAX_INSTRUMENTS)) return FALSE;
+	if ((!nInstr) || (nInstr >= MAX_INSTRUMENTS)) return false;
 	if ((!ReadXIInstrument(nInstr, lpMemFile, dwFileLength))
 	 && (!ReadPATInstrument(nInstr, lpMemFile, dwFileLength))
 	 && (!ReadITIInstrument(nInstr, lpMemFile, dwFileLength))
 	// Generic read
-	 && (!ReadSampleAsInstrument(nInstr, lpMemFile, dwFileLength))) return FALSE;
+	 && (!ReadSampleAsInstrument(nInstr, lpMemFile, dwFileLength))) return false;
 	if (nInstr > m_nInstruments) m_nInstruments = nInstr;
-	return TRUE;
+	return true;
 }
 
 
-BOOL CSoundFile::ReadSampleAsInstrument(UINT nInstr, LPBYTE lpMemFile, DWORD dwFileLength)
-//----------------------------------------------------------------------------------------
+bool CSoundFile::ReadSampleAsInstrument(INSTRUMENTINDEX nInstr, LPBYTE lpMemFile, DWORD dwFileLength)
+//---------------------------------------------------------------------------------------------------
 {
 	LPDWORD psig = (LPDWORD)lpMemFile;
-	if ((!lpMemFile) || (dwFileLength < 128)) return FALSE;
+	if ((!lpMemFile) || (dwFileLength < 128)) return false;
 	if (((psig[0] == 0x46464952) && (psig[2] == 0x45564157))	// RIFF....WAVE signature
 	 || ((psig[0] == 0x5453494C) && (psig[2] == 0x65766177))	// LIST....wave
 	 || (psig[76/4] == 0x53524353)								// S3I signature
@@ -59,7 +59,7 @@
 	{
 		// Loading Instrument
 		MODINSTRUMENT *pIns = new MODINSTRUMENT;
-		if (!pIns) return FALSE;
+		if (!pIns) return false;
 		memset(pIns, 0, sizeof(MODINSTRUMENT));
 		pIns->pTuning = pIns->s_DefaultTuning;
 // -> CODE#0003
@@ -91,21 +91,20 @@
 			pIns->NoteMap[iinit] = iinit+1;
 		}
 		if (nSample) ReadSampleFromFile(nSample, lpMemFile, dwFileLength);
-		return TRUE;
+		return true;
 	}
-	return FALSE;
+	return false;
 }
 
 
 // -> CODE#0003
 // -> DESC="remove instrument's samples"
 // BOOL CSoundFile::DestroyInstrument(UINT nInstr)
-BOOL CSoundFile::DestroyInstrument(UINT nInstr, char removeSamples)
-// -! BEHAVIOUR_CHANGE#0003
-//---------------------------------------------
+bool CSoundFile::DestroyInstrument(INSTRUMENTINDEX nInstr, char removeSamples)
+//----------------------------------------------------------------------------
 {
-	if ((!nInstr) || (nInstr > m_nInstruments)) return FALSE;
-	if (!Instruments[nInstr]) return TRUE;
+	if ((!nInstr) || (nInstr > m_nInstruments)) return false;
+	if (!Instruments[nInstr]) return true;
 
 // -> CODE#0003
 // -> DESC="remove instrument's samples"
@@ -117,7 +116,7 @@
 // -> CODE#0023
 // -> DESC="IT project files (.itp)"
 	m_szInstrumentPath[nInstr-1][0] = '\0';
-	instrumentModified[nInstr-1] = FALSE;
+	instrumentModified[nInstr-1] = false;
 // -! NEW_FEATURE#0023
 
 	MODINSTRUMENT *pIns = Instruments[nInstr];
@@ -130,14 +129,14 @@
 		}
 	}
 	delete pIns;
-	return TRUE;
+	return true;
 }
 
 
-BOOL CSoundFile::IsSampleUsed(UINT nSample)
-//-----------------------------------------
+bool CSoundFile::IsSampleUsed(SAMPLEINDEX nSample)
+//------------------------------------------------
 {
-	if ((!nSample) || (nSample > m_nSamples)) return FALSE;
+	if ((!nSample) || (nSample > m_nSamples)) return false;
 	if (m_nInstruments)
 	{
 		for (UINT i=1; i<=m_nInstruments; i++) if (Instruments[i])
@@ -145,7 +144,7 @@
 			MODINSTRUMENT *pIns = Instruments[i];
 			for (UINT j=0; j<128; j++)
 			{
-				if (pIns->Keyboard[j] == nSample) return TRUE;
+				if (pIns->Keyboard[j] == nSample) return true;
 			}
 		}
 	} else
@@ -155,33 +154,33 @@
 			MODCOMMAND *m = Patterns[i];
 			for (UINT j=m_nChannels*PatternSize[i]; j; m++, j--)
 			{
-				if (m->instr == nSample) return TRUE;
+				if (m->instr == nSample) return true;
 			}
 		}
 	}
-	return FALSE;
+	return false;
 }
 
 
-BOOL CSoundFile::IsInstrumentUsed(UINT nInstr)
-//--------------------------------------------
+bool CSoundFile::IsInstrumentUsed(INSTRUMENTINDEX nInstr)
+//-------------------------------------------------------
 {
-	if ((!nInstr) || (nInstr > m_nInstruments) || (!Instruments[nInstr])) return FALSE;
+	if ((!nInstr) || (nInstr > m_nInstruments) || (!Instruments[nInstr])) return false;
 	for (UINT i=0; i<Patterns.Size(); i++) if (Patterns[i])
 	{
 		MODCOMMAND *m = Patterns[i];
 		for (UINT j=m_nChannels*PatternSize[i]; j; m++, j--)
 		{
-			if (m->instr == nInstr) return TRUE;
+			if (m->instr == nInstr) return true;
 		}
 	}
-	return FALSE;
+	return false;
 }
 
 
 // Removing all unused samples
-BOOL CSoundFile::RemoveInstrumentSamples(UINT nInstr)
-//---------------------------------------------------
+bool CSoundFile::RemoveInstrumentSamples(INSTRUMENTINDEX nInstr)
+//--------------------------------------------------------------
 {
 	BYTE sampleused[MAX_SAMPLES/8];
 	
@@ -194,23 +193,23 @@
 			UINT n = p->Keyboard[r];
 			if (n < MAX_SAMPLES) sampleused[n>>3] |= (1<<(n&7));
 		}
-		for (UINT smp=1; smp<MAX_INSTRUMENTS; smp++) if ((Instruments[smp]) && (smp != nInstr))
+		for (SAMPLEINDEX nSmp=1; nSmp<MAX_INSTRUMENTS; nSmp++) if ((Instruments[nSmp]) && (nSmp != nInstr))
 		{
-			p = Instruments[smp];
+			p = Instruments[nSmp];
 			for (UINT r=0; r<128; r++)
 			{
 				UINT n = p->Keyboard[r];
 				if (n < MAX_SAMPLES) sampleused[n>>3] &= ~(1<<(n&7));
 			}
 		}
-		for (UINT d=1; d<=m_nSamples; d++) if (sampleused[d>>3] & (1<<(d&7)))
+		for (SAMPLEINDEX d = 1; d <= m_nSamples; d++) if (sampleused[d>>3] & (1<<(d&7)))
 		{
 			DestroySample(d);
 			m_szNames[d][0] = 0;
 		}
-		return TRUE;
+		return true;
 	}
-	return FALSE;
+	return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -218,11 +217,11 @@
 // I/O From another song
 //
 
-BOOL CSoundFile::ReadInstrumentFromSong(UINT nInstr, CSoundFile *pSrcSong, UINT nSrcInstr)
-//----------------------------------------------------------------------------------------
+bool CSoundFile::ReadInstrumentFromSong(INSTRUMENTINDEX nInstr, CSoundFile *pSrcSong, UINT nSrcInstr)
+//---------------------------------------------------------------------------------------------------
 {
 	if ((!pSrcSong) || (!nSrcInstr) || (nSrcInstr > pSrcSong->m_nInstruments)
-	 || (nInstr >= MAX_INSTRUMENTS) || (!pSrcSong->Instruments[nSrcInstr])) return FALSE;
+	 || (nInstr >= MAX_INSTRUMENTS) || (!pSrcSong->Instruments[nSrcInstr])) return false;
 	if (m_nInstruments < nInstr) m_nInstruments = nInstr;
 // -> CODE#0003
 // -> DESC="remove instrument's samples"
@@ -277,16 +276,16 @@
 		{
 			ReadSampleFromSong(samplemap[k], pSrcSong, samplesrc[k]);
 		}
-		return TRUE;
+		return true;
 	}
-	return FALSE;
+	return false;
 }
 
 
-BOOL CSoundFile::ReadSampleFromSong(UINT nSample, CSoundFile *pSrcSong, UINT nSrcSample)
-//--------------------------------------------------------------------------------------
+bool CSoundFile::ReadSampleFromSong(SAMPLEINDEX nSample, CSoundFile *pSrcSong, UINT nSrcSample)
+//---------------------------------------------------------------------------------------------
 {
-	if ((!pSrcSong) || (!nSrcSample) || (nSrcSample > pSrcSong->m_nSamples) || (nSample >= MAX_SAMPLES)) return FALSE;
+	if ((!pSrcSong) || (!nSrcSample) || (nSrcSample > pSrcSong->m_nSamples) || (nSample >= MAX_SAMPLES)) return false;
 	MODSAMPLE *psmp = &pSrcSong->Samples[nSrcSample];
 	UINT nSize = psmp->nLength;
 	if (psmp->uFlags & CHN_16BIT) nSize *= 2;
@@ -318,7 +317,7 @@
 	{
 		FrequencyToTranspose(&Samples[nSample]);
 	}
-	return TRUE;
+	return true;
 }
 
 
@@ -330,8 +329,8 @@
 
 extern BOOL IMAADPCMUnpack16(signed short *pdest, UINT nLen, LPBYTE psrc, DWORD dwBytes, UINT pkBlkAlign);
 
-BOOL CSoundFile::ReadWAVSample(UINT nSample, LPBYTE lpMemFile, DWORD dwFileLength, DWORD *pdwWSMPOffset)
-//------------------------------------------------------------------------------------------------------
+bool CSoundFile::ReadWAVSample(SAMPLEINDEX nSample, LPBYTE lpMemFile, DWORD dwFileLength, DWORD *pdwWSMPOffset)
+//-------------------------------------------------------------------------------------------------------------
 {
 	DWORD dwMemPos = 0, dwDataPos;
 	WAVEFILEHEADER *phdr = (WAVEFILEHEADER *)lpMemFile;
@@ -341,9 +340,9 @@
 	WAVEEXTRAHEADER *pxh;
 	DWORD dwInfoList, dwFact, dwSamplesPerBlock;
 	
-	if ((!nSample) || (!lpMemFile) || (dwFileLength < (DWORD)(sizeof(WAVEFILEHEADER)+sizeof(WAVEFORMATHEADER)))) return FALSE;
+	if ((!nSample) || (!lpMemFile) || (dwFileLength < (DWORD)(sizeof(WAVEFILEHEADER)+sizeof(WAVEFORMATHEADER)))) return false;
 	if (((phdr->id_RIFF != IFFID_RIFF) && (phdr->id_RIFF != IFFID_LIST))
-	 || ((phdr->id_WAVE != IFFID_WAVE) && (phdr->id_WAVE != IFFID_wave))) return FALSE;
+	 || ((phdr->id_WAVE != IFFID_WAVE) && (phdr->id_WAVE != IFFID_wave))) return false;
 	dwMemPos = sizeof(WAVEFILEHEADER);
 	dwDataPos = 0;
 	pfmt = NULL;
@@ -410,7 +409,7 @@
 		}
 		dwMemPos += dwLen + 8;
 	}
-	if ((!pdata) || (!pfmt) || (pdata->length < 4)) return FALSE;
+	if ((!pdata) || (!pfmt) || (pdata->length < 4)) return false;
 	if ((pfmtpk) && (pfmt))
 	{
 		if (pfmt->format != 1)
@@ -419,7 +418,7 @@
 			pfmt = pfmtpk;
 			pfmtpk = tmp;
 			if ((pfmtpk->format != 0x11) || (pfmtpk->bitspersample != 4)
-			 || (pfmtpk->channels != 1)) return FALSE;
+			 || (pfmtpk->channels != 1)) return false;
 		} else pfmtpk = NULL;
 	}
 	// WAVE_FORMAT_PCM, WAVE_FORMAT_IEEE_FLOAT, WAVE_FORMAT_EXTENSIBLE
@@ -430,7 +429,7 @@
 	 || (pfmt->bitspersample & 7)
 	 || (!pfmt->bitspersample)
 	 || (pfmt->bitspersample > 32)
-	) return FALSE;
+	) return false;
 
 	DestroySample(nSample);
 	UINT nType = RS_PCM8U;
@@ -570,14 +569,14 @@
 			}
 		}
 	}
-	return TRUE;
+	return true;
 }
 
 
 ///////////////////////////////////////////////////////////////
 // Save WAV
 
-BOOL CSoundFile::SaveWAVSample(UINT nSample, LPCSTR lpszFileName)
+bool CSoundFile::SaveWAVSample(UINT nSample, LPCSTR lpszFileName)
 //---------------------------------------------------------------
 {
 	LPCSTR lpszMPT = "Modplug Tracker\0";
@@ -590,7 +589,7 @@
 	MODSAMPLE *pSmp = &Samples[nSample];
 	FILE *f;
 
-	if ((f = fopen(lpszFileName, "wb")) == NULL) return FALSE;
+	if ((f = fopen(lpszFileName, "wb")) == NULL) return false;
 	memset(&extra, 0, sizeof(extra));
 	memset(&smpl, 0, sizeof(smpl));
 	header.id_RIFF = IFFID_RIFF;
@@ -679,19 +678,19 @@
 	extra.nVibRate = pSmp->nVibRate;
 	fwrite(&extra, 1, sizeof(extra), f);
 	fclose(f);
-	return TRUE;
+	return true;
 }
 
 ///////////////////////////////////////////////////////////////
 // Save RAW
 
-BOOL CSoundFile::SaveRAWSample(UINT nSample, LPCSTR lpszFileName)
+bool CSoundFile::SaveRAWSample(UINT nSample, LPCSTR lpszFileName)
 //---------------------------------------------------------------
 {
 	MODSAMPLE *pSmp = &Samples[nSample];
 	FILE *f;
 
-	if ((f = fopen(lpszFileName, "wb")) == NULL) return FALSE;
+	if ((f = fopen(lpszFileName, "wb")) == NULL) return false;
 
 	UINT nType;
 	if (pSmp->uFlags & CHN_STEREO)
@@ -700,7 +699,7 @@
 		nType = (pSmp->uFlags & CHN_16BIT) ? RS_PCM16S : RS_PCM8S;
 	WriteSample(f, pSmp, nType);
 	fclose(f);
-	return TRUE;
+	return true;
 }
 
 /////////////////////////////////////////////////////////////
@@ -867,8 +866,8 @@
 }
 
 
-BOOL CSoundFile::ReadPATSample(UINT nSample, LPBYTE lpStream, DWORD dwMemLength)
-//------------------------------------------------------------------------------
+bool CSoundFile::ReadPATSample(SAMPLEINDEX nSample, LPBYTE lpStream, DWORD dwMemLength)
+//-------------------------------------------------------------------------------------
 {
 	DWORD dwMemPos = sizeof(GF1PATCHFILEHEADER)+sizeof(GF1INSTRUMENT)+sizeof(GF1LAYER);
 	GF1PATCHFILEHEADER *phdr = (GF1PATCHFILEHEADER *)lpStream;
@@ -877,7 +876,7 @@
 	if ((!lpStream) || (dwMemLength < 512)
 	 || (phdr->gf1p != 0x50314647) || (phdr->atch != 0x48435441)
 	 || (phdr->version[3] != 0) || (phdr->id[9] != 0) || (phdr->instrum < 1)
-	 || (!phdr->samples) || (!pinshdr->layers)) return FALSE;
+	 || (!phdr->samples) || (!pinshdr->layers)) return false;
 	DestroySample(nSample);
 	PatchToSample(this, nSample, lpStream+dwMemPos, dwMemLength-dwMemPos);
 	if (pinshdr->name[0] > ' ')
@@ -885,13 +884,13 @@
 		memcpy(m_szNames[nSample], pinshdr->name, 16);
 		m_szNames[nSample][16] = 0;
 	}
-	return TRUE;
+	return true;
 }
 
 
 // PAT Instrument
-BOOL CSoundFile::ReadPATInstrument(UINT nInstr, LPBYTE lpStream, DWORD dwMemLength)
-//---------------------------------------------------------------------------------
+bool CSoundFile::ReadPATInstrument(INSTRUMENTINDEX nInstr, LPBYTE lpStream, DWORD dwMemLength)
+//--------------------------------------------------------------------------------------------
 {
 	GF1PATCHFILEHEADER *phdr = (GF1PATCHFILEHEADER *)lpStream;
 	GF1INSTRUMENT *pih = (GF1INSTRUMENT *)(lpStream+sizeof(GF1PATCHFILEHEADER));
@@ -904,7 +903,7 @@
 	 || (phdr->gf1p != 0x50314647) || (phdr->atch != 0x48435441)
 	 || (phdr->version[3] != 0) || (phdr->id[9] != 0)
 	 || (phdr->instrum < 1) || (!phdr->samples)
-	 || (!pih->layers) || (!plh->samples)) return FALSE;
+	 || (!pih->layers) || (!plh->samples)) return false;
 	if (nInstr > m_nInstruments) m_nInstruments = nInstr;
 // -> CODE#0003
 // -> DESC="remove instrument's samples"
@@ -912,7 +911,7 @@
 	DestroyInstrument(nInstr,1);
 // -! BEHAVIOUR_CHANGE#0003
 	pIns = new MODINSTRUMENT;
-	if (!pIns) return FALSE;
+	if (!pIns) return false;
 	memset(pIns, 0, sizeof(MODINSTRUMENT));
 	pIns->pTuning = pIns->s_DefaultTuning;
 	Instruments[nInstr] = pIns;
@@ -1004,7 +1003,7 @@
 			}
 		}
 	}
-	return TRUE;
+	return true;
 }
 
 
@@ -1032,8 +1031,8 @@
 	DWORD scrs;
 } S3ISAMPLESTRUCT;
 
-BOOL CSoundFile::ReadS3ISample(UINT nSample, LPBYTE lpMemFile, DWORD dwFileLength)
-//--------------------------------------------------------------------------------
+bool CSoundFile::ReadS3ISample(SAMPLEINDEX nSample, LPBYTE lpMemFile, DWORD dwFileLength)
+//---------------------------------------------------------------------------------------
 {
 	S3ISAMPLESTRUCT *pss = (S3ISAMPLESTRUCT *)lpMemFile;
 	MODSAMPLE *pSmp = &Samples[nSample];
@@ -1042,7 +1041,7 @@
 
 	if ((!lpMemFile) || (dwFileLength < sizeof(S3ISAMPLESTRUCT))
 	 || (pss->id != 0x01) || (((DWORD)pss->offset << 4) >= dwFileLength)
-	 || (pss->scrs != 0x53524353)) return FALSE;
+	 || (pss->scrs != 0x53524353)) return false;
 	DestroySample(nSample);
 	dwMemPos = pss->offset << 4;
 	memcpy(pSmp->filename, pss->filename, 12);
@@ -1063,7 +1062,7 @@
 	flags = (pss->flags & 0x04) ? RS_PCM16U : RS_PCM8U;
 	if (pss->flags & 0x02) flags |= RSF_STEREO;
 	ReadSample(pSmp, flags, (LPSTR)(lpMemFile+dwMemPos), dwFileLength-dwMemPos);
-	return TRUE;
+	return true;
 }
 
 
@@ -1112,8 +1111,8 @@
 
 
 
-BOOL CSoundFile::ReadXIInstrument(UINT nInstr, LPBYTE lpMemFile, DWORD dwFileLength)
-//----------------------------------------------------------------------------------
+bool CSoundFile::ReadXIInstrument(INSTRUMENTINDEX nInstr, LPBYTE lpMemFile, DWORD dwFileLength)
+//---------------------------------------------------------------------------------------------
 {
 	XIFILEHEADER *pxh = (XIFILEHEADER *)lpMemFile;
 	XIINSTRUMENTHEADER *pih = (XIINSTRUMENTHEADER *)(lpMemFile+sizeof(XIFILEHEADER));
@@ -1123,11 +1122,11 @@
 	DWORD dwMemPos = sizeof(XIFILEHEADER)+sizeof(XIINSTRUMENTHEADER);
 	UINT nsamples;
 
-	if ((!lpMemFile) || (dwFileLength < sizeof(XIFILEHEADER)+sizeof(XIINSTRUMENTHEADER))) return FALSE;
-	if (dwMemPos + pxh->shsize - 0x102 >= dwFileLength) return FALSE;
-	if (memcmp(pxh->extxi, "Extended Instrument", 19)) return FALSE;
+	if ((!lpMemFile) || (dwFileLength < sizeof(XIFILEHEADER)+sizeof(XIINSTRUMENTHEADER))) return false;
+	if (dwMemPos + pxh->shsize - 0x102 >= dwFileLength) return false;
+	if (memcmp(pxh->extxi, "Extended Instrument", 19)) return false;
 	dwMemPos += pxh->shsize - 0x102;
-	if ((dwMemPos < sizeof(XIFILEHEADER)) || (dwMemPos >= dwFileLength)) return FALSE;
+	if ((dwMemPos < sizeof(XIFILEHEADER)) || (dwMemPos >= dwFileLength)) return false;
 	if (nInstr > m_nInstruments) m_nInstruments = nInstr;
 // -> CODE#0003
 // -> DESC="remove instrument's samples"
@@ -1136,7 +1135,7 @@
 // -! BEHAVIOUR_CHANGE#0003
 	Instruments[nInstr] = new MODINSTRUMENT;
 	MODINSTRUMENT *pIns = Instruments[nInstr];
-	if (!pIns) return FALSE;
+	if (!pIns) return false;
 	memset(pIns, 0, sizeof(MODINSTRUMENT));
 	pIns->pTuning = pIns->s_DefaultTuning;
 	memcpy(pIns->name, pxh->name, 22);
@@ -1295,18 +1294,18 @@
 // -> DESC="per-instrument volume ramping setup (refered as attack)"
 
 	// Leave if no extra instrument settings are available (end of file reached)
-	if(dwMemPos >= dwFileLength) return TRUE;
+	if(dwMemPos >= dwFileLength) return true;
 
 	ReadExtendedInstrumentProperties(pIns, lpMemFile + dwMemPos, dwFileLength - dwMemPos);
 
 // -! NEW_FEATURE#0027
 
-	return TRUE;
+	return true;
 }
 
 
-BOOL CSoundFile::SaveXIInstrument(UINT nInstr, LPCSTR lpszFileName)
-//-----------------------------------------------------------------
+bool CSoundFile::SaveXIInstrument(INSTRUMENTINDEX nInstr, LPCSTR lpszFileName)
+//----------------------------------------------------------------------------
 {
 	XIFILEHEADER xfh;
 	XIINSTRUMENTHEADER xih;
@@ -1316,8 +1315,8 @@
 	UINT nsamples;
 	FILE *f;
 
-	if ((!pIns) || (!lpszFileName)) return FALSE;
-	if ((f = fopen(lpszFileName, "wb")) == NULL) return FALSE;
+	if ((!pIns) || (!lpszFileName)) return false;
+	if ((f = fopen(lpszFileName, "wb")) == NULL) return false;
 	// XI File Header
 	memset(&xfh, 0, sizeof(xfh));
 	memset(&xih, 0, sizeof(xih));
@@ -1431,12 +1430,12 @@
 
 
 	fclose(f);
-	return TRUE;
+	return true;
 }
 
 
-BOOL CSoundFile::ReadXISample(UINT nSample, LPBYTE lpMemFile, DWORD dwFileLength)
-//-------------------------------------------------------------------------------
+bool CSoundFile::ReadXISample(SAMPLEINDEX nSample, LPBYTE lpMemFile, DWORD dwFileLength)
+//--------------------------------------------------------------------------------------
 {
 	XIFILEHEADER *pxh = (XIFILEHEADER *)lpMemFile;
 	XIINSTRUMENTHEADER *pih = (XIINSTRUMENTHEADER *)(lpMemFile+sizeof(XIFILEHEADER));
@@ -1445,10 +1444,10 @@
 	MODSAMPLE *pSmp = &Samples[nSample];
 	UINT nsamples;
 
-	if ((!lpMemFile) || (dwFileLength < sizeof(XIFILEHEADER)+sizeof(XIINSTRUMENTHEADER))) return FALSE;
-	if (memcmp(pxh->extxi, "Extended Instrument", 19)) return FALSE;
+	if ((!lpMemFile) || (dwFileLength < sizeof(XIFILEHEADER)+sizeof(XIINSTRUMENTHEADER))) return false;
+	if (memcmp(pxh->extxi, "Extended Instrument", 19)) return false;
 	dwMemPos += pxh->shsize - 0x102;
-	if ((dwMemPos < sizeof(XIFILEHEADER)) || (dwMemPos >= dwFileLength)) return FALSE;
+	if ((dwMemPos < sizeof(XIFILEHEADER)) || (dwMemPos >= dwFileLength)) return false;
 	DestroySample(nSample);
 	nsamples = 0;
 	for (UINT i=0; i<96; i++)
@@ -1516,9 +1515,9 @@
 		memcpy(pSmp->filename, psh->name, 22);
 		pSmp->filename[21] = 0;
 	}
-	if (dwMemPos >= dwFileLength) return TRUE;
+	if (dwMemPos >= dwFileLength) return true;
 	ReadSample(pSmp, sampleflags, (LPSTR)(lpMemFile+dwMemPos), dwFileLength-dwMemPos);
-	return TRUE;
+	return true;
 }
 
 
@@ -1580,8 +1579,8 @@
 
 
 
-BOOL CSoundFile::ReadAIFFSample(UINT nSample, LPBYTE lpMemFile, DWORD dwFileLength)
-//---------------------------------------------------------------------------------
+bool CSoundFile::ReadAIFFSample(SAMPLEINDEX nSample, LPBYTE lpMemFile, DWORD dwFileLength)
+//----------------------------------------------------------------------------------------
 {
 	DWORD dwMemPos = sizeof(AIFFFILEHEADER);
 	DWORD dwFORMLen, dwCOMMLen, dwSSNDLen;
@@ -1590,22 +1589,22 @@
 	AIFFSSND *psnd;
 	UINT nType;
 
-	if ((!lpMemFile) || (dwFileLength < (DWORD)sizeof(AIFFFILEHEADER))) return FALSE;
+	if ((!lpMemFile) || (dwFileLength < (DWORD)sizeof(AIFFFILEHEADER))) return false;
 	dwFORMLen = BigEndian(phdr->dwLen);
 	if ((phdr->dwFORM != 0x4D524F46) || (phdr->dwAIFF != 0x46464941)
-	 || (dwFORMLen > dwFileLength) || (dwFORMLen < (DWORD)sizeof(AIFFCOMM))) return FALSE;
+	 || (dwFORMLen > dwFileLength) || (dwFORMLen < (DWORD)sizeof(AIFFCOMM))) return false;
 	pcomm = (AIFFCOMM *)(lpMemFile+dwMemPos);
 	dwCOMMLen = BigEndian(pcomm->dwLen);
-	if ((pcomm->dwCOMM != 0x4D4D4F43) || (dwCOMMLen < 0x12) || (dwCOMMLen >= dwFileLength)) return FALSE;
-	if ((pcomm->wChannels != 0x0100) && (pcomm->wChannels != 0x0200)) return FALSE;
-	if ((pcomm->wSampleSize != 0x0800) && (pcomm->wSampleSize != 0x1000)) return FALSE;
+	if ((pcomm->dwCOMM != 0x4D4D4F43) || (dwCOMMLen < 0x12) || (dwCOMMLen >= dwFileLength)) return false;
+	if ((pcomm->wChannels != 0x0100) && (pcomm->wChannels != 0x0200)) return false;
+	if ((pcomm->wSampleSize != 0x0800) && (pcomm->wSampleSize != 0x1000)) return false;
 	dwMemPos += dwCOMMLen + 8;
-	if (dwMemPos + sizeof(AIFFSSND) >= dwFileLength) return FALSE;
+	if (dwMemPos + sizeof(AIFFSSND) >= dwFileLength) return false;
 	psnd = (AIFFSSND *)(lpMemFile+dwMemPos);
 	dwSSNDLen = BigEndian(psnd->dwLen);
-	if ((psnd->dwSSND != 0x444E5353) || (dwSSNDLen >= dwFileLength) || (dwSSNDLen < 8)) return FALSE;
+	if ((psnd->dwSSND != 0x444E5353) || (dwSSNDLen >= dwFileLength) || (dwSSNDLen < 8)) return false;
 	dwMemPos += sizeof(AIFFSSND);
-	if (dwMemPos >= dwFileLength) return FALSE;
+	if (dwMemPos >= dwFileLength) return false;
 	DestroySample(nSample);
 	if (pcomm->wChannels == 0x0100)
 	{
@@ -1641,7 +1640,7 @@
 	m_szNames[nSample][0] = 0;
 	if (pSmp->nLength > MAX_SAMPLE_LENGTH) pSmp->nLength = MAX_SAMPLE_LENGTH;
 	ReadSample(pSmp, nType, (LPSTR)(lpMemFile+dwMemPos), dwFileLength-dwMemPos);
-	return TRUE;
+	return true;
 }
 
 
@@ -1651,9 +1650,8 @@
 // -> CODE#0027
 // -> DESC="per-instrument volume ramping setup (refered as attack)"
 //BOOL CSoundFile::ReadITSSample(UINT nSample, LPBYTE lpMemFile, DWORD dwFileLength, DWORD dwOffset)
-UINT CSoundFile::ReadITSSample(UINT nSample, LPBYTE lpMemFile, DWORD dwFileLength, DWORD dwOffset)
-// -! NEW_FEATURE#0027
-//------------------------------------------------------------------------------------------------
+UINT CSoundFile::ReadITSSample(SAMPLEINDEX nSample, LPBYTE lpMemFile, DWORD dwFileLength, DWORD dwOffset)
+//-------------------------------------------------------------------------------------------------------
 {
 	ITSAMPLESTRUCT *pis = (ITSAMPLESTRUCT *)lpMemFile;
 	MODSAMPLE *pSmp = &Samples[nSample];
@@ -1728,8 +1726,8 @@
 }
 
 
-BOOL CSoundFile::ReadITIInstrument(UINT nInstr, LPBYTE lpMemFile, DWORD dwFileLength)
-//-----------------------------------------------------------------------------------
+bool CSoundFile::ReadITIInstrument(INSTRUMENTINDEX nInstr, LPBYTE lpMemFile, DWORD dwFileLength)
+//----------------------------------------------------------------------------------------------
 {
 	ITINSTRUMENT *pinstr = (ITINSTRUMENT *)lpMemFile;
 	WORD samplemap[NOTE_MAX];	//rewbs.noSamplePerInstroLimit (120 was 64)
@@ -1737,7 +1735,7 @@
 	UINT nsmp, nsamples;
 
 	if ((!lpMemFile) || (dwFileLength < sizeof(ITINSTRUMENT))
-	 || (pinstr->id != 0x49504D49)) return FALSE;
+	 || (pinstr->id != 0x49504D49)) return false;
 	if (nInstr > m_nInstruments) m_nInstruments = nInstr;
 // -> CODE#0003
 // -> DESC="remove instrument's samples"
@@ -1746,7 +1744,7 @@
 // -! BEHAVIOUR_CHANGE#0003
 	Instruments[nInstr] = new MODINSTRUMENT;
 	MODINSTRUMENT *pIns = Instruments[nInstr];
-	if (!pIns) return FALSE;
+	if (!pIns) return false;
 	memset(pIns, 0, sizeof(MODINSTRUMENT));
 	pIns->pTuning = pIns->s_DefaultTuning;
 	memset(samplemap, 0, sizeof(samplemap));
@@ -1805,18 +1803,18 @@
 	ITSAMPLESTRUCT *pis = (ITSAMPLESTRUCT *)ptr;
 	dwMemPos += pis->samplepointer - dwMemPos + lastSampleSize;
 	// Leave if no extra instrument settings are available (end of file reached)
-	if(dwMemPos >= dwFileLength) return TRUE;
+	if(dwMemPos >= dwFileLength) return true;
 
 	ReadExtendedInstrumentProperties(pIns, lpMemFile + dwMemPos, dwFileLength - dwMemPos);
 
 // -! NEW_FEATURE#0027
 
-	return TRUE;
+	return true;
 }
 
 
-BOOL CSoundFile::SaveITIInstrument(UINT nInstr, LPCSTR lpszFileName)
-//------------------------------------------------------------------
+bool CSoundFile::SaveITIInstrument(INSTRUMENTINDEX nInstr, LPCSTR lpszFileName)
+//-----------------------------------------------------------------------------
 {
 	BYTE buffer[554];
 	ITINSTRUMENT *iti = (ITINSTRUMENT *)buffer;
@@ -1826,8 +1824,8 @@
 	DWORD dwPos;
 	FILE *f;
 
-	if ((!pIns) || (!lpszFileName)) return FALSE;
-	if ((f = fopen(lpszFileName, "wb")) == NULL) return FALSE;
+	if ((!pIns) || (!lpszFileName)) return false;
+	if ((f = fopen(lpszFileName, "wb")) == NULL) return false;
 	memset(buffer, 0, sizeof(buffer));
 	memset(smpcount, 0, sizeof(smpcount));
 	memset(smptable, 0, sizeof(smptable));
@@ -1999,7 +1997,7 @@
 	WriteInstrumentHeaderStruct(pIns, f);	// Write full extended header.
 
 	fclose(f);
-	return TRUE;
+	return true;
 }
 
 
@@ -2112,8 +2110,8 @@
 
 
 
-BOOL CSoundFile::Read8SVXSample(UINT nSample, LPBYTE lpMemFile, DWORD dwFileLength)
-//--------------------------------------------------------------------------------
+bool CSoundFile::Read8SVXSample(UINT nSample, LPBYTE lpMemFile, DWORD dwFileLength)
+//---------------------------------------------------------------------------------
 {
 	IFF8SVXFILEHEADER *pfh = (IFF8SVXFILEHEADER *)lpMemFile;
 	IFFVHDR *pvh = (IFFVHDR *)(lpMemFile + 12);
@@ -2122,7 +2120,7 @@
 	
 	if ((!lpMemFile) || (dwFileLength < sizeof(IFFVHDR)+12) || (pfh->dwFORM != IFFID_FORM)
 	 || (pfh->dw8SVX != IFFID_8SVX) || (BigEndian(pfh->dwSize) >= dwFileLength)
-	 || (pvh->dwVHDR != IFFID_VHDR) || (BigEndian(pvh->dwSize) >= dwFileLength)) return FALSE;
+	 || (pvh->dwVHDR != IFFID_VHDR) || (BigEndian(pvh->dwSize) >= dwFileLength)) return false;
 	DestroySample(nSample);
 	// Default values
 	pSmp->nGlobalVol = 64;
@@ -2174,7 +2172,7 @@
 		}
 		dwMemPos += dwChunkLen + 8;
 	}
-	return TRUE;
+	return true;
 }
 
 

Modified: trunk/OpenMPT/soundlib/Snd_fx.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Snd_fx.cpp	2009-09-13 20:41:27 UTC (rev 363)
+++ trunk/OpenMPT/soundlib/Snd_fx.cpp	2009-09-15 17:15:29 UTC (rev 364)
@@ -3083,7 +3083,7 @@
 	MODCHANNEL *pChn = &Chn[nChn];
 	UINT nRetrigSpeed = param & 0x0F;
 	UINT nRetrigCount = pChn->nRetrigCount;
-	BOOL bDoRetrig = FALSE;
+	bool bDoRetrig = false;
 
 	if(IsCompatibleMode(TRK_IMPULSETRACKER))
 	{
@@ -3095,7 +3095,7 @@
 		else if (!pChn->nRetrigCount || !--pChn->nRetrigCount)
 		{
 			pChn->nRetrigCount = param & 0xf;
-			bDoRetrig = TRUE;
+			bDoRetrig = true;
 		}
 	}
 	else
@@ -3103,7 +3103,7 @@
 		if (m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT|MOD_TYPE_MPT))
 		{
 			if (!nRetrigSpeed) nRetrigSpeed = 1;
-			if ((nRetrigCount) && (!(nRetrigCount % nRetrigSpeed))) bDoRetrig = TRUE;
+			if ((nRetrigCount) && (!(nRetrigCount % nRetrigSpeed))) bDoRetrig = true;
 			nRetrigCount++;
 		} else
 		{
@@ -3112,12 +3112,12 @@
 			if ((m_nTickCount) || (param & 0x100))
 			{
 				if (!realspeed) realspeed = 1;
-				if ((!(param & 0x100)) && (m_nMusicSpeed) && (!(m_nTickCount % realspeed))) bDoRetrig = TRUE;
+				if ((!(param & 0x100)) && (m_nMusicSpeed) && (!(m_nTickCount % realspeed))) bDoRetrig = true;
 				nRetrigCount++;
 			} else if (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2)) nRetrigCount = 0;
 			if (nRetrigCount >= realspeed)
 			{
-				if ((m_nTickCount) || ((param & 0x100) && (!pChn->nRowNote))) bDoRetrig = TRUE;
+				if ((m_nTickCount) || ((param & 0x100) && (!pChn->nRowNote))) bDoRetrig = true;
 			}
 		}
 	}
@@ -3152,12 +3152,13 @@
 			if ((pChn->nRowInstr) && (param < 0x100)) { InstrumentChange(pChn, pChn->nRowInstr, FALSE, FALSE); bResetEnv = TRUE; }
 			if (param < 0x100) bResetEnv = TRUE;
 		}
-		NoteChange(nChn, nNote, false, bResetEnv);
+		NoteChange(nChn, nNote, IsCompatibleMode(TRK_IMPULSETRACKER) ? true : false, bResetEnv);
 		if (m_nInstruments) {
 			ProcessMidiOut(nChn, pChn);	//Send retrig to Midi
 		}
 		if ((m_nType & (MOD_TYPE_IT|MOD_TYPE_MPT)) && (!pChn->nRowNote) && (nOldPeriod)) pChn->nPeriod = nOldPeriod;
 		if (!(m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT|MOD_TYPE_MPT))) nRetrigCount = 0;
+		if(IsCompatibleMode(TRK_IMPULSETRACKER)) pChn->nPos = pChn->nPosLo = 0;
 
 		if (offset)									//rewbs.volOffset: apply offset on retrig
 		{

Modified: trunk/OpenMPT/soundlib/Sndfile.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Sndfile.cpp	2009-09-13 20:41:27 UTC (rev 363)
+++ trunk/OpenMPT/soundlib/Sndfile.cpp	2009-09-15 17:15:29 UTC (rev 364)
@@ -1337,10 +1337,10 @@
 	//m_nSeqOverride = 0;
 }
 
-int CSoundFile::FindOrder(PATTERNINDEX pat, UINT startFromOrder, bool direction)
-//----------------------------------------------------------------------
+ORDERINDEX CSoundFile::FindOrder(PATTERNINDEX pat, UINT startFromOrder, bool direction)
+//-------------------------------------------------------------------------------------
 {
-	int foundAtOrder = -1;
+	int foundAtOrder = ORDERINDEX_INVALID;
 	int candidateOrder = 0;
 
 	for (UINT p=0; p<Order.size(); p++) 	{
@@ -1708,15 +1708,15 @@
 }
 
 
-BOOL CSoundFile::CanPackSample(LPSTR pSample, UINT nLen, UINT nPacking, BYTE *result)
-//-----------------------------------------------------------------------------------
+bool CSoundFile::CanPackSample(LPSTR pSample, UINT nLen, UINT nPacking, BYTE *result/*=NULL*/)
+//--------------------------------------------------------------------------------------------
 {
 	int pos, old, oldpos, besttable = 0;
 	DWORD dwErr, dwTotal, dwResult;
 	int i,j;
 	
 	if (result) *result = 0;
-	if ((!pSample) || (nLen < 1024)) return FALSE;
+	if ((!pSample) || (nLen < 1024)) return false;
 	// Try packing with different tables
 	dwResult = 0;
 	for (j=1; j<MAX_PACK_TABLES; j++)
@@ -1746,7 +1746,7 @@
 	{
 		if (dwResult > 100) *result	= 100; else *result = (BYTE)dwResult;
 	}
-	return (dwResult >= nPacking) ? TRUE : FALSE;
+	return (dwResult >= nPacking) ? true : false;
 }
 #endif // NO_PACKING
 
@@ -2743,10 +2743,10 @@
 }
 
 
-BOOL CSoundFile::RemoveSelectedSamples(BOOL *pbIns)
+bool CSoundFile::RemoveSelectedSamples(bool *pbIns)
 //-------------------------------------------------
 {
-	if (!pbIns) return FALSE;
+	if (!pbIns) return false;
 	for (UINT j=1; j<MAX_SAMPLES; j++)
 	{
 		if ((!pbIns[j]) && (Samples[j].pSample))
@@ -2755,15 +2755,15 @@
 			if ((j == m_nSamples) && (j > 1)) m_nSamples--;
 		}
 	}
-	return TRUE;
+	return true;
 }
 
 
-BOOL CSoundFile::DestroySample(UINT nSample)
-//------------------------------------------
+bool CSoundFile::DestroySample(SAMPLEINDEX nSample)
+//-------------------------------------------------
 {
-	if ((!nSample) || (nSample >= MAX_SAMPLES)) return FALSE;
-	if (!Samples[nSample].pSample) return TRUE;
+	if ((!nSample) || (nSample >= MAX_SAMPLES)) return false;
+	if (!Samples[nSample].pSample) return true;
 	MODSAMPLE *pSmp = &Samples[nSample];
 	LPSTR pSample = pSmp->pSample;
 	pSmp->pSample = nullptr;
@@ -2778,13 +2778,13 @@
 		}
 	}
 	FreeSample(pSample);
-	return TRUE;
+	return true;
 }
 
 // -> CODE#0020
 // -> DESC="rearrange sample list"
-bool CSoundFile::MoveSample(UINT from, UINT to)
-//---------------------------------------------
+bool CSoundFile::MoveSample(SAMPLEINDEX from, SAMPLEINDEX to)
+//-----------------------------------------------------------
 {
 	if (!from || from >= MAX_SAMPLES || !to || to >= MAX_SAMPLES) return false;
 	if (/*!Ins[from].pSample ||*/ Samples[to].pSample) return true;

Modified: trunk/OpenMPT/soundlib/Sndfile.h
===================================================================
--- trunk/OpenMPT/soundlib/Sndfile.h	2009-09-13 20:41:27 UTC (rev 363)
+++ trunk/OpenMPT/soundlib/Sndfile.h	2009-09-15 17:15:29 UTC (rev 364)
@@ -634,7 +634,7 @@
 	static const CModSpecifications& GetModSpecifications(const MODTYPE type);
 
 	double GetCurrentBPM() const;
-	int FindOrder(PATTERNINDEX pat, UINT startFromOrder=0, bool direction=true);	//rewbs.playSongFromCursor
+	ORDERINDEX FindOrder(PATTERNINDEX pat, UINT startFromOrder=0, bool direction=true);	//rewbs.playSongFromCursor
 	void DontLoopPattern(int nPat, int nRow=0);		//rewbs.playSongFromCursor
 	void SetCurrentPos(UINT nPos);
 	void SetCurrentOrder(UINT nOrder);
@@ -848,55 +848,54 @@
 	// Read/Write sample functions
 	char GetDeltaValue(char prev, UINT n) const { return (char)(prev + CompressionTable[n & 0x0F]); }
 	UINT PackSample(int &sample, int next);
-	BOOL CanPackSample(LPSTR pSample, UINT nLen, UINT nPacking, BYTE *result=NULL);
+	bool CanPackSample(LPSTR pSample, UINT nLen, UINT nPacking, BYTE *result=NULL);
 	UINT ReadSample(MODSAMPLE *pSmp, UINT nFlags, LPCSTR pMemFile, DWORD dwMemLength, const WORD format = 1);
-	BOOL DestroySample(UINT nSample);
+	bool DestroySample(SAMPLEINDEX nSample);
 
 // -> CODE#0020
 // -> DESC="rearrange sample list"
-	bool MoveSample(UINT from,UINT to);
+	bool MoveSample(SAMPLEINDEX from, SAMPLEINDEX to);
 // -! NEW_FEATURE#0020
 
 // -> CODE#0003
 // -> DESC="remove instrument's samples"
 	//BOOL DestroyInstrument(UINT nInstr);
-	BOOL DestroyInstrument(UINT nInstr, char removeSamples = 0);
+	bool DestroyInstrument(INSTRUMENTINDEX nInstr, char removeSamples = 0);
 // -! BEHAVIOUR_CHANGE#0003
-	BOOL IsSampleUsed(UINT nSample);
-	BOOL IsInstrumentUsed(UINT nInstr);
-	BOOL RemoveInstrumentSamples(UINT nInstr);
+	bool IsSampleUsed(SAMPLEINDEX nSample);
+	bool IsInstrumentUsed(INSTRUMENTINDEX nInstr);
+	bool RemoveInstrumentSamples(INSTRUMENTINDEX nInstr);
 	UINT DetectUnusedSamples(BYTE *); // bitmask
-	BOOL RemoveSelectedSamples(BOOL *);
+	bool RemoveSelectedSamples(bool *pbIns);
 	void AdjustSampleLoop(MODSAMPLE *pSmp);
 	// Samples file I/O
-	BOOL ReadSampleFromFile(UINT nSample, LPBYTE lpMemFile, DWORD dwFileLength);
-	BOOL ReadWAVSample(UINT nSample, LPBYTE lpMemFile, DWORD dwFileLength, DWORD *pdwWSMPOffset=NULL);
-	BOOL ReadPATSample(UINT nSample, LPBYTE lpMemFile, DWORD dwFileLength);
-	BOOL ReadS3ISample(UINT nSample, LPBYTE lpMemFile, DWORD dwFileLength);
-	BOOL ReadAIFFSample(UINT nSample, LPBYTE lpMemFile, DWORD dwFileLength);
-	BOOL ReadXISample(UINT nSample, LPBYTE lpMemFile, DWORD dwFileLength);
+	bool ReadSampleFromFile(SAMPLEINDEX nSample, LPBYTE lpMemFile, DWORD dwFileLength);
+	bool ReadWAVSample(SAMPLEINDEX nSample, LPBYTE lpMemFile, DWORD dwFileLength, DWORD *pdwWSMPOffset=NULL);
+	bool ReadPATSample(SAMPLEINDEX nSample, LPBYTE lpMemFile, DWORD dwFileLength);
+	bool ReadS3ISample(SAMPLEINDEX nSample, LPBYTE lpMemFile, DWORD dwFileLength);
+	bool ReadAIFFSample(SAMPLEINDEX nSample, LPBYTE lpMemFile, DWORD dwFileLength);
+	bool ReadXISample(SAMPLEINDEX nSample, LPBYTE lpMemFile, DWORD dwFileLength);
 
 // -> CODE#0027
 // -> DESC="per-instrument volume ramping setup (refered as attack)"
 //	BOOL ReadITSSample(UINT nSample, LPBYTE lpMemFile, DWORD dwFileLength, DWORD dwOffset=0);
-	UINT ReadITSSample(UINT nSample, LPBYTE lpMemFile, DWORD dwFileLength, DWORD dwOffset=0);
+	UINT ReadITSSample(SAMPLEINDEX nSample, LPBYTE lpMemFile, DWORD dwFileLength, DWORD dwOffset=0);
 // -! NEW_FEATURE#0027
 
-	BOOL ReadITISample(UINT nSample, LPBYTE lpMemFile, DWORD dwFileLength);
-	BOOL Read8SVXSample(UINT nInstr, LPBYTE lpMemFile, DWORD dwFileLength);
-	BOOL SaveWAVSample(UINT nSample, LPCSTR lpszFileName);
-	BOOL SaveRAWSample(UINT nSample, LPCSTR lpszFileName);
+	bool Read8SVXSample(UINT nInstr, LPBYTE lpMemFile, DWORD dwFileLength);
+	bool SaveWAVSample(UINT nSample, LPCSTR lpszFileName);
+	bool SaveRAWSample(UINT nSample, LPCSTR lpszFileName);
 	// Instrument file I/O
-	BOOL ReadInstrumentFromFile(UINT nInstr, LPBYTE lpMemFile, DWORD dwFileLength);
-	BOOL ReadXIInstrument(UINT nInstr, LPBYTE lpMemFile, DWORD dwFileLength);
-	BOOL ReadITIInstrument(UINT nInstr, LPBYTE lpMemFile, DWORD dwFileLength);
-	BOOL ReadPATInstrument(UINT nInstr, LPBYTE lpMemFile, DWORD dwFileLength);
-	BOOL ReadSampleAsInstrument(UINT nInstr, LPBYTE lpMemFile, DWORD dwFileLength);
-	BOOL SaveXIInstrument(UINT nInstr, LPCSTR lpszFileName);
-	BOOL SaveITIInstrument(UINT nInstr, LPCSTR lpszFileName);
+	bool ReadInstrumentFromFile(INSTRUMENTINDEX nInstr, LPBYTE lpMemFile, DWORD dwFileLength);
+	bool ReadXIInstrument(INSTRUMENTINDEX nInstr, LPBYTE lpMemFile, DWORD dwFileLength);
+	bool ReadITIInstrument(INSTRUMENTINDEX nInstr, LPBYTE lpMemFile, DWORD dwFileLength);
+	bool ReadPATInstrument(INSTRUMENTINDEX nInstr, LPBYTE lpMemFile, DWORD dwFileLength);
+	bool ReadSampleAsInstrument(INSTRUMENTINDEX nInstr, LPBYTE lpMemFile, DWORD dwFileLength);
+	bool SaveXIInstrument(INSTRUMENTINDEX nInstr, LPCSTR lpszFileName);
+	bool SaveITIInstrument(INSTRUMENTINDEX nInstr, LPCSTR lpszFileName);
 	// I/O from another sound file
-	BOOL ReadInstrumentFromSong(UINT nInstr, CSoundFile *, UINT nSrcInstrument);
-	BOOL ReadSampleFromSong(UINT nSample, CSoundFile *, UINT nSrcSample);
+	bool ReadInstrumentFromSong(INSTRUMENTINDEX nInstr, CSoundFile *pSrcSong, UINT nSrcInstrument);
+	bool ReadSampleFromSong(SAMPLEINDEX nSample, CSoundFile *pSrcSong, UINT nSrcSample);
 	// Period/Note functions
 	UINT GetNoteFromPeriod(UINT period) const;
 	UINT GetPeriodFromNote(UINT note, int nFineTune, UINT nC5Speed) const;


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-09-13 20:41:39

Revision: 363
          http://modplug.svn.sourceforge.net/modplug/?rev=363&view=rev
Author:   saga-games
Date:     2009-09-13 20:41:27 +0000 (Sun, 13 Sep 2009)

Log Message:
-----------
[New] Sequence Editor: Added context menu item "Render to wave", to render one ore more patterns to wave.
[New] Sample Editor: Added setting "FinetuneStep" to INI section "Sample Editor"
[Fix] Sample Editor: When using the spin control, frequency is not clamped to [2000, 96000] anymore.
[Imp] Pattern Editor: Don't reset "replace all" flag after every search

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/Ctrl_pat.h
    trunk/OpenMPT/mptrack/Ctrl_seq.cpp
    trunk/OpenMPT/mptrack/Ctrl_smp.cpp
    trunk/OpenMPT/mptrack/Ctrl_smp.h
    trunk/OpenMPT/mptrack/Mod2wave.cpp
    trunk/OpenMPT/mptrack/Moddoc.cpp
    trunk/OpenMPT/mptrack/Moddoc.h
    trunk/OpenMPT/mptrack/View_pat.cpp
    trunk/OpenMPT/mptrack/mod2wave.h
    trunk/OpenMPT/mptrack/resource.h

Modified: trunk/OpenMPT/mptrack/Ctrl_pat.h
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_pat.h	2009-09-13 13:44:24 UTC (rev 362)
+++ trunk/OpenMPT/mptrack/Ctrl_pat.h	2009-09-13 20:41:27 UTC (rev 363)
@@ -101,6 +101,7 @@
 	afx_msg void OnSwitchToView();
 	afx_msg void OnInsertOrder();
 	afx_msg void OnDeleteOrder();
+	afx_msg void OnRenderOrder();
 	afx_msg void OnPatternProperties();
 	afx_msg void OnPlayerPlay();
 	afx_msg void OnPlayerPause();

Modified: trunk/OpenMPT/mptrack/Ctrl_seq.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_seq.cpp	2009-09-13 13:44:24 UTC (rev 362)
+++ trunk/OpenMPT/mptrack/Ctrl_seq.cpp	2009-09-13 20:41:27 UTC (rev 363)
@@ -43,6 +43,7 @@
 	ON_COMMAND(ID_CONTROLTAB,			OnSwitchToView)
 	ON_COMMAND(ID_ORDERLIST_INSERT,		OnInsertOrder)
 	ON_COMMAND(ID_ORDERLIST_DELETE,		OnDeleteOrder)
+	ON_COMMAND(ID_ORDERLIST_RENDER,		OnRenderOrder)
 	ON_COMMAND(ID_PATTERN_PROPERTIES,	OnPatternProperties)
 	ON_COMMAND(ID_PLAYER_PLAY,			OnPlayerPlay)
 	ON_COMMAND(ID_PLAYER_PAUSE,			OnPlayerPause)
@@ -831,6 +832,9 @@
 			AppendMenu(hMenu, MF_STRING | greyed, ID_PATTERN_PROPERTIES, "&Properties...");
 		}
 	}
+	AppendMenu(hMenu, MF_SEPARATOR, NULL, "");
+	AppendMenu(hMenu, MF_STRING, ID_ORDERLIST_RENDER, "Render to &Wave");
+
 	ClientToScreen(&pt);
 	::TrackPopupMenu(hMenu, TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt.x, pt.y, 0, m_hWnd, NULL);
 	::DestroyMenu(hMenu);
@@ -939,7 +943,14 @@
 	}
 }
 
+void COrderList::OnRenderOrder()
+//------------------------------
+{
+	ORD_SELECTION selection = GetCurSel(false);
+	m_pModDoc->OnFileWaveConvert(selection.nOrdLo, selection.nOrdHi);
+}
 
+
 void COrderList::OnDeleteOrder()
 //------------------------------
 {

Modified: trunk/OpenMPT/mptrack/Ctrl_smp.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_smp.cpp	2009-09-13 13:44:24 UTC (rev 362)
+++ trunk/OpenMPT/mptrack/Ctrl_smp.cpp	2009-09-13 20:41:27 UTC (rev 363)
@@ -402,6 +402,9 @@
 		}
 	}
 	SetCurrentSample((lParam > 0) ? lParam : m_nSample);
+
+	m_nFinetuneStep = CMainFrame::GetPrivateProfileLong("Sample Editor", "FinetuneStep", 25, theApp.GetConfigFileName());
+
 	// Initial Update
 	// 05/01/05 : ericus replaced "m_nSample << 24" by "m_nSample << 20" : 4000 samples -> 12bits [see Moddoc.h]
 	if (!m_bInitialized) UpdateView((m_nSample << HINT_SHIFT_SMP) | HINT_SAMPLEINFO | HINT_MODTYPE, NULL);
@@ -3121,12 +3124,10 @@
 	{
 		if (m_pSndFile->m_nType & (MOD_TYPE_S3M|MOD_TYPE_IT|MOD_TYPE_MPT))
 		{
-			LONG d = pSmp->nC5Speed;
+			UINT d = pSmp->nC5Speed;
 			if (d < 1) d = 8363;
-			d += (pos * 25);
-			if (d > 96000) d = 96000;
-			if (d < 2000) d = 2000;
-			pSmp->nC5Speed = d;
+			d += (pos * m_nFinetuneStep);
+			pSmp->nC5Speed = CLAMP(d, 579, 139921); // B-8, C-1
 			int transp = CSoundFile::FrequencyToTranspose(pSmp->nC5Speed) >> 7;
 			int basenote = 60 - transp;
 			if (basenote < BASENOTE_MIN) basenote = BASENOTE_MIN;

Modified: trunk/OpenMPT/mptrack/Ctrl_smp.h
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_smp.h	2009-09-13 13:44:24 UTC (rev 362)
+++ trunk/OpenMPT/mptrack/Ctrl_smp.h	2009-09-13 20:41:27 UTC (rev 363)
@@ -23,6 +23,7 @@
 	uint32 m_nSequenceMs;
 	uint32 m_nSeekWindowMs;
 	uint32 m_nOverlapMs;
+	uint16 m_nFinetuneStep; // Increment finetune by x when using spin control. Default = 25
 	enum {nDefaultStretchChunkSize = 8192};
 
 	CComboBox m_ComboPitch, m_ComboQuality, m_ComboFFT;

Modified: trunk/OpenMPT/mptrack/Mod2wave.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Mod2wave.cpp	2009-09-13 13:44:24 UTC (rev 362)
+++ trunk/OpenMPT/mptrack/Mod2wave.cpp	2009-09-13 20:41:27 UTC (rev 363)
@@ -57,14 +57,24 @@
 END_MESSAGE_MAP()
 
 
-CWaveConvert::CWaveConvert(CWnd *parent):CDialog(IDD_WAVECONVERT, parent)
-//-----------------------------------------------------------------------
+CWaveConvert::CWaveConvert(CWnd *parent, ORDERINDEX nMinOrder, ORDERINDEX nMaxOrder):
+	CDialog(IDD_WAVECONVERT, parent)
+//-----------------------------------------------------------------------------------
 {
 	m_bGivePlugsIdleTime = false;
 	m_bNormalize = FALSE;
 	m_bHighQuality = FALSE;
 	m_bSelectPlay = FALSE;
-	m_nMinOrder = m_nMaxOrder = 0;
+	if(nMinOrder != ORDERINDEX_INVALID && nMaxOrder != ORDERINDEX_INVALID)
+	{
+		// render selection
+		m_nMinOrder = nMinOrder;
+		m_nMaxOrder = nMaxOrder;
+		m_bSelectPlay = true;
+	} else
+	{
+		m_nMinOrder = m_nMaxOrder = 0;
+	}
 	m_dwFileLimit = 0;
 	m_dwSongLimit = 0;
 	memset(&WaveFormat, 0, sizeof(WaveFormat));
@@ -110,6 +120,8 @@
 
 	SetDlgItemInt(IDC_EDIT3, m_nMinOrder);
 	SetDlgItemInt(IDC_EDIT4, m_nMaxOrder);
+	
+
 	for (UINT i=0; i<NUMMIXRATE; i++)
 	{
 		UINT n = nMixingRates[i];

Modified: trunk/OpenMPT/mptrack/Moddoc.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Moddoc.cpp	2009-09-13 13:44:24 UTC (rev 362)
+++ trunk/OpenMPT/mptrack/Moddoc.cpp	2009-09-13 20:41:27 UTC (rev 363)
@@ -1388,6 +1388,12 @@
 void CModDoc::OnFileWaveConvert()
 //-------------------------------
 {
+	OnFileWaveConvert(0, 0);
+}
+
+void CModDoc::OnFileWaveConvert(ORDERINDEX nMinOrder, ORDERINDEX nMaxOrder)
+//-------------------------------------------------------------------------
+{
 	TCHAR fname[_MAX_FNAME]="";
 	CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
 
@@ -1398,7 +1404,7 @@
 					"Wave Files (*.wav)|*.wav||", pMainFrm);
 	dlg.m_ofn.lpstrInitialDir = CMainFrame::GetWorkingDirectory(DIR_EXPORT);
 
-	CWaveConvert wsdlg(pMainFrm);
+	CWaveConvert wsdlg(pMainFrm, nMinOrder, nMaxOrder);
 	if (wsdlg.DoModal() != IDOK) return;
 	if (dlg.DoModal() != IDOK) return; //rewbs: made filename dialog appear after wav settings dialog
 
@@ -1409,9 +1415,7 @@
 	strcpy(s, dlg.GetPathName());
 
 	// Saving as wave file
-// -> CODE#0024
-// -> DESC="wav export update"
-	UINT p = 0,n = 1;
+	UINT p = 0, n = 1;
 	DWORD flags[MAX_BASECHANNELS];
 	CHAR channel[MAX_CHANNELNAME+10];
 
@@ -1434,38 +1438,12 @@
 	dwcdlg.m_dwSongLimit = wsdlg.m_dwSongLimit;
 	dwcdlg.m_nMaxPatterns = (wsdlg.m_bSelectPlay) ? wsdlg.m_nMaxOrder - wsdlg.m_nMinOrder + 1 : 0;
 	//if(wsdlg.m_bHighQuality) CSoundFile::SetResamplingMode(SRCMODE_POLYPHASE);
-// -! NEW_FEATURE#0024
 
 	BOOL bplaying = FALSE;
 	UINT pos = m_SndFile.GetCurrentPos();
 	bplaying = TRUE;
 	pMainFrm->PauseMod();
 
-// rewbs.fix3239: moved position definition into loop below
-/*  m_SndFile.SetCurrentPos(0);
-	if (wsdlg.m_bSelectPlay)
-	{
-		m_SndFile.SetCurrentOrder(wsdlg.m_nMinOrder);
-		m_SndFile.m_nCurrentPattern = wsdlg.m_nMinOrder;
-		m_SndFile.GetLength(TRUE, FALSE);
-		m_SndFile.m_nMaxOrderPosition = wsdlg.m_nMaxOrder + 1;
-	}
-*/
-//end rewbs.fix3239: moved position definition into loop below
-	// Saving file
-
-// -> CODE#0024
-// -> DESC="wav export update"
-//		CDoWaveConvert dwcdlg(&m_SndFile, s, &wsdlg.WaveFormat.Format, wsdlg.m_bNormalize, pMainFrm);
-//		dwcdlg.m_dwFileLimit = wsdlg.m_dwFileLimit;
-//		dwcdlg.m_dwSongLimit = wsdlg.m_dwSongLimit;
-//		dwcdlg.m_nMaxPatterns = (wsdlg.m_bSelectPlay) ? wsdlg.m_nMaxOrder - wsdlg.m_nMinOrder + 1 : 0;
-//		if (wsdlg.m_bHighQuality)
-//		{
-//			CSoundFile::SetResamplingMode(SRCMODE_POLYPHASE);
-//		}
-//		dwcdlg.DoModal();
-
 	for(UINT i = 0 ; i < n ; i++){
 
 		// Channel mode
@@ -1504,7 +1482,6 @@
 	if(wsdlg.m_bChannelMode){
 		for(UINT i = 0 ; i < n ; i++) m_SndFile.ChnSettings[i].dwFlags = flags[i];
 	}
-// -! NEW_FEATURE#0024
 
 	m_SndFile.SetCurrentPos(pos);
 	m_SndFile.GetLength(TRUE);

Modified: trunk/OpenMPT/mptrack/Moddoc.h
===================================================================
--- trunk/OpenMPT/mptrack/Moddoc.h	2009-09-13 13:44:24 UTC (rev 362)
+++ trunk/OpenMPT/mptrack/Moddoc.h	2009-09-13 20:41:27 UTC (rev 363)
@@ -268,6 +268,8 @@
 	CSize GetOldPatternScrollbarsPos() const { return m_szOldPatternScrollbarsPos; };
 	void SetOldPatternScrollbarsPos( CSize s ){ m_szOldPatternScrollbarsPos = s; };
 
+	void OnFileWaveConvert(ORDERINDEX nMinOrder, ORDERINDEX nMaxOrder);
+
 // protected members
 protected:
 	CSize m_szOldPatternScrollbarsPos;

Modified: trunk/OpenMPT/mptrack/View_pat.cpp
===================================================================
--- trunk/OpenMPT/mptrack/View_pat.cpp	2009-09-13 13:44:24 UTC (rev 362)
+++ trunk/OpenMPT/mptrack/View_pat.cpp	2009-09-13 20:41:27 UTC (rev 363)
@@ -1946,7 +1946,7 @@
 	m_bContinueSearch = TRUE;
 	EndWaitCursor();
 	// Display search results
-	m_dwReplaceFlags &= ~PATSEARCH_REPLACEALL;
+	//m_dwReplaceFlags &= ~PATSEARCH_REPLACEALL;
 	if (!nFound)
 	{
 		if (m_dwFindFlags & PATSEARCH_NOTE)

Modified: trunk/OpenMPT/mptrack/mod2wave.h
===================================================================
--- trunk/OpenMPT/mptrack/mod2wave.h	2009-09-13 13:44:24 UTC (rev 362)
+++ trunk/OpenMPT/mptrack/mod2wave.h	2009-09-13 20:41:27 UTC (rev 363)
@@ -14,7 +14,7 @@
 	ULONGLONG m_dwFileLimit;
 	DWORD m_dwSongLimit;
 	BOOL m_bSelectPlay, m_bNormalize, m_bHighQuality, m_bGivePlugsIdleTime;
-	UINT m_nMinOrder, m_nMaxOrder;
+	ORDERINDEX m_nMinOrder, m_nMaxOrder;
 	CComboBox m_CbnSampleRate, m_CbnSampleFormat;
 	CEdit m_EditMinOrder, m_EditMaxOrder;
 
@@ -24,7 +24,7 @@
 // -! NEW_FEATURE#0024
 
 public:
-	CWaveConvert(CWnd *parent);
+	CWaveConvert(CWnd *parent, ORDERINDEX nMinOrder = ORDERINDEX_INVALID, ORDERINDEX nMaxOrder = ORDERINDEX_INVALID);
 
 public:
 	void UpdateDialog();

Modified: trunk/OpenMPT/mptrack/resource.h
===================================================================
--- trunk/OpenMPT/mptrack/resource.h	2009-09-13 13:44:24 UTC (rev 362)
+++ trunk/OpenMPT/mptrack/resource.h	2009-09-13 20:41:27 UTC (rev 363)
@@ -1116,6 +1116,7 @@
 #define ID_OVERFLOWPASTE                59226
 #define ID_NOTEMAP_COPY_NOTE            59227
 #define ID_CLEANUP_REARRANGESAMPLES     59228
+#define ID_ORDERLIST_RENDER				59229
 
 // Next default values for new objects
 // 
@@ -1123,7 +1124,7 @@
 #ifndef APSTUDIO_READONLY_SYMBOLS
 #define _APS_3D_CONTROLS                     1
 #define _APS_NEXT_RESOURCE_VALUE        521
-#define _APS_NEXT_COMMAND_VALUE         59229
+#define _APS_NEXT_COMMAND_VALUE         59230
 #define _APS_NEXT_CONTROL_VALUE         2387
 #define _APS_NEXT_SYMED_VALUE           901
 #endif


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-09-13 13:44:34

Revision: 362
          http://modplug.svn.sourceforge.net/modplug/?rev=362&view=rev
Author:   saga-games
Date:     2009-09-13 13:44:24 +0000 (Sun, 13 Sep 2009)

Log Message:
-----------
[Fix] XM Compatibility: Portamento + New Note with no previous note (tentative fix), Offset beyond sample range
[Fix] IT Compatibility: Offset beyond sample range
[Ref] Replaced some NULLs and BOOL variables by nullptrs and bools

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/Moddoc.cpp
    trunk/OpenMPT/mptrack/Modedit.cpp
    trunk/OpenMPT/soundlib/Sampleio.cpp
    trunk/OpenMPT/soundlib/Snd_flt.cpp
    trunk/OpenMPT/soundlib/Snd_fx.cpp
    trunk/OpenMPT/soundlib/Sndfile.cpp
    trunk/OpenMPT/soundlib/Sndfile.h
    trunk/OpenMPT/soundlib/Sndmix.cpp

Modified: trunk/OpenMPT/mptrack/Moddoc.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Moddoc.cpp	2009-09-11 19:32:52 UTC (rev 361)
+++ trunk/OpenMPT/mptrack/Moddoc.cpp	2009-09-13 13:44:24 UTC (rev 362)
@@ -849,7 +849,7 @@
 		else if ((nsmp) && (nsmp < MAX_SAMPLES)) {	//Or set sample
 			MODSAMPLE *pSmp = &m_SndFile.Samples[nsmp];
 			pChn->pCurrentSample = pSmp->pSample;
-			pChn->pModInstrument = NULL;
+			pChn->pModInstrument = nullptr;
 			pChn->pModSample = pSmp;
 			pChn->pSample = pSmp->pSample;
 			pChn->nFineTune = pSmp->nFineTune;
@@ -864,13 +864,13 @@
 			pChn->nFadeOutVol = 0x10000;
 		}
 
-		m_SndFile.NoteChange(nChn, note, FALSE, TRUE, TRUE);
+		m_SndFile.NoteChange(nChn, note, false, true, true);
 		if (nVol >= 0) pChn->nVolume = nVol;
 		
 		// handle sample looping.
 		// Fix: Bug report 1700.
 		//if ((loopstart + 16 < loopend) && (loopstart >= 0) && (loopend <= (LONG)pChn->nLength)) 	{
-		if ((loopstart + 16 < loopend) && (loopstart >= 0) && (pChn->pModSample != 0))
+		if ((loopstart + 16 < loopend) && (loopstart >= 0) && (pChn->pModSample != nullptr))
 		{
 			pChn->nPos = loopstart;
 			pChn->nPosLo = 0;

Modified: trunk/OpenMPT/mptrack/Modedit.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Modedit.cpp	2009-09-11 19:32:52 UTC (rev 361)
+++ trunk/OpenMPT/mptrack/Modedit.cpp	2009-09-13 13:44:24 UTC (rev 362)
@@ -142,7 +142,7 @@
 		// Removing all instrument headers
 		for (UINT i1=0; i1<MAX_CHANNELS; i1++)
 		{
-			m_SndFile.Chn[i1].pModInstrument = NULL;
+			m_SndFile.Chn[i1].pModInstrument = nullptr;
 		}
 		for (UINT i2=0; i2<m_SndFile.m_nInstruments; i2++) if (m_SndFile.Instruments[i2])
 		{

Modified: trunk/OpenMPT/soundlib/Sampleio.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Sampleio.cpp	2009-09-11 19:32:52 UTC (rev 361)
+++ trunk/OpenMPT/soundlib/Sampleio.cpp	2009-09-13 13:44:24 UTC (rev 362)
@@ -126,7 +126,7 @@
 	{
 		if (Chn[i].pModInstrument == pIns)
 		{
-			Chn[i].pModInstrument = NULL;
+			Chn[i].pModInstrument = nullptr;
 		}
 	}
 	delete pIns;
@@ -450,7 +450,7 @@
 	if (pSmp->pSample)
 	{
 		FreeSample(pSmp->pSample);
-		pSmp->pSample = NULL;
+		pSmp->pSample = nullptr;
 		pSmp->nLength = 0;
 	}
 	pSmp->nLength = pdata->length / samplesize;
@@ -1620,7 +1620,7 @@
 	if (pSmp->pSample)
 	{
 		FreeSample(pSmp->pSample);
-		pSmp->pSample = NULL;
+		pSmp->pSample = nullptr;
 		pSmp->nLength = 0;
 	}
 	pSmp->nLength = dwSSNDLen / samplesize;

Modified: trunk/OpenMPT/soundlib/Snd_flt.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Snd_flt.cpp	2009-09-11 19:32:52 UTC (rev 361)
+++ trunk/OpenMPT/soundlib/Snd_flt.cpp	2009-09-13 13:44:24 UTC (rev 362)
@@ -70,7 +70,7 @@
 
 
 // Simple 2-poles resonant filter
-void CSoundFile::SetupChannelFilter(MODCHANNEL *pChn, BOOL bReset, int flt_modifier) const
+void CSoundFile::SetupChannelFilter(MODCHANNEL *pChn, bool bReset, int flt_modifier) const
 //----------------------------------------------------------------------------------------
 {
 	float fs = (float)gdwMixingFreq;

Modified: trunk/OpenMPT/soundlib/Snd_fx.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Snd_fx.cpp	2009-09-11 19:32:52 UTC (rev 361)
+++ trunk/OpenMPT/soundlib/Snd_fx.cpp	2009-09-13 13:44:24 UTC (rev 362)
@@ -538,7 +538,7 @@
 	// Invalid sample ?
 	if (!pSmp)
 	{
-		pChn->pModSample = NULL;
+		pChn->pModSample = nullptr;
 		pChn->nInsVol = 0;
 		return;
 	}
@@ -612,7 +612,7 @@
 }
 
 
-void CSoundFile::NoteChange(UINT nChn, int note, BOOL bPorta, BOOL bResetEnv, BOOL bManual)
+void CSoundFile::NoteChange(UINT nChn, int note, bool bPorta, bool bResetEnv, bool bManual)
 //-----------------------------------------------------------------------------------------
 {
 	if (note < 1) return;
@@ -677,6 +677,10 @@
 	// IT Compatibility: Update multisample instruments frequency even if instrument is not specified
 	if(!bPorta && pSmp && IsCompatibleMode(TRK_IMPULSETRACKER)) pChn->nC5Speed = pSmp->nC5Speed;
 
+	// XM Compatibility: Ignore notes with portamento if there was no note
+	if(bPorta && (pChn->nPeriod == 0) && IsCompatibleMode(TRK_FASTTRACKER2))
+		return;
+
 	if (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2|MOD_TYPE_MED)) note += pChn->nTranspose;
 	note = CLAMP(note, 1, 132);
 	pChn->nNote = note;
@@ -723,7 +727,7 @@
 		if (pChn->nPos >= pChn->nLength) pChn->nPos = pChn->nLoopStart;
 	} 
 	else 
-		bPorta = FALSE;
+		bPorta = false;
 
 	if ((!bPorta) || (!(m_nType & (MOD_TYPE_IT|MOD_TYPE_MPT)))
 	 || ((pChn->dwFlags & CHN_NOTEFADE) && (!pChn->nFadeOutVol))
@@ -804,12 +808,12 @@
 			pChn->nAutoVibPos = 0;
 		}
 		pChn->nLeftVol = pChn->nRightVol = 0;
-		BOOL bFlt = (m_dwSongFlags & SONG_MPTFILTERMODE) ? FALSE : TRUE;
+		bool bFlt = (m_dwSongFlags & SONG_MPTFILTERMODE) ? false : true;
 		// Setup Initial Filter for this note
 		if (pIns)
 		{
-			if (pIns->nIFR & 0x80) { pChn->nResonance = pIns->nIFR & 0x7F; bFlt = TRUE; }
-			if (pIns->nIFC & 0x80) { pChn->nCutOff = pIns->nIFC & 0x7F; bFlt = TRUE; }
+			if (pIns->nIFR & 0x80) { pChn->nResonance = pIns->nIFR & 0x7F; bFlt = true; }
+			if (pIns->nIFC & 0x80) { pChn->nCutOff = pIns->nIFC & 0x7F; bFlt = true; }
 			if (bFlt && (pIns->nFilterMode != FLTMODE_UNCHANGED)) {
 				pChn->nFilterMode = pIns->nFilterMode;
 			}
@@ -819,7 +823,7 @@
 			pChn->nCutSwing = pChn->nResSwing = 0;
 		}
 #ifndef NO_FILTER
-		if ((pChn->nCutOff < 0x7F) && (bFlt)) SetupChannelFilter(pChn, TRUE);
+		if ((pChn->nCutOff < 0x7F) && (bFlt)) SetupChannelFilter(pChn, true);
 #endif // NO_FILTER
 	}
 	// Special case for MPT
@@ -913,7 +917,7 @@
 				note = pHeader->NoteMap[note-1];
 				if ((n) && (n < MAX_SAMPLES)) pSample = Samples[n].pSample;
 			}
-		} else pSample = NULL;
+		} else pSample = nullptr;
 	}
 	MODCHANNEL *p = pChn;
 	//if (!pIns) return;
@@ -1337,7 +1341,7 @@
 					InstrumentChange(pChn, pChn->nNewIns, bPorta, FALSE, (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2)) ? FALSE : TRUE);
 					pChn->nNewIns = 0;
 				}
-				NoteChange(nChn, note, bPorta, (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2)) ? FALSE : TRUE);
+				NoteChange(nChn, note, bPorta, (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2)) ? false : true);
 				if ((bPorta) && (m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2)) && (instr))
 				{
 					pChn->dwFlags |= CHN_FASTVOLRAMP;
@@ -2780,7 +2784,7 @@
 				if (oldcutoff < 0) oldcutoff = -oldcutoff;
 				if ((pChn->nVolume > 0) || (oldcutoff < 0x10)
 				|| (!(pChn->dwFlags & CHN_FILTER)) || (!(pChn->nLeftVol|pChn->nRightVol)))
-					SetupChannelFilter(pChn, (pChn->dwFlags & CHN_FILTER) ? FALSE : TRUE);
+					SetupChannelFilter(pChn, (pChn->dwFlags & CHN_FILTER) ? false : true);
 			#endif // NO_FILTER
 			}
 			break;
@@ -2794,7 +2798,7 @@
 			}
 				
 		#ifndef NO_FILTER
-			SetupChannelFilter(pChn, (pChn->dwFlags & CHN_FILTER) ? FALSE : TRUE);
+			SetupChannelFilter(pChn, (pChn->dwFlags & CHN_FILTER) ? false : true);
 		#endif // NO_FILTER
 			break;
 
@@ -2804,7 +2808,7 @@
 			{
 				pChn->nFilterMode = (dwParam>>4);
 			#ifndef NO_FILTER
-				SetupChannelFilter(pChn, (pChn->dwFlags & CHN_FILTER) ? FALSE : TRUE);
+				SetupChannelFilter(pChn, (pChn->dwFlags & CHN_FILTER) ? false : true);
 			#endif // NO_FILTER
 			}
 			break;
@@ -2916,7 +2920,7 @@
 			if (oldcutoff < 0) oldcutoff = -oldcutoff;
 			if ((pChn->nVolume > 0) || (oldcutoff < 0x10)
 			|| (!(pChn->dwFlags & CHN_FILTER)) || (!(pChn->nLeftVol|pChn->nRightVol)))
-				SetupChannelFilter(pChn, (pChn->dwFlags & CHN_FILTER) ? FALSE : TRUE);
+				SetupChannelFilter(pChn, (pChn->dwFlags & CHN_FILTER) ? false : true);
 		#endif // NO_FILTER
 		} break;
 	
@@ -2935,7 +2939,7 @@
 				pChn->nResonance = (BYTE) (pChn->m_nPlugInitialParamValue + (m_nTickCount+1)*pChn->m_nPlugParamValueStep + 0.5);
 				pChn->nRestoreResonanceOnNewNote = 0;
 			#ifndef NO_FILTER
-				SetupChannelFilter(pChn, (pChn->dwFlags & CHN_FILTER) ? FALSE : TRUE);
+				SetupChannelFilter(pChn, (pChn->dwFlags & CHN_FILTER) ? false : true);
 			#endif // NO_FILTER	
 			}
 
@@ -2947,7 +2951,7 @@
 			{
 				pChn->nFilterMode = (dwParam>>4);
 			#ifndef NO_FILTER
-				SetupChannelFilter(pChn, (pChn->dwFlags & CHN_FILTER) ? FALSE : TRUE);
+				SetupChannelFilter(pChn, (pChn->dwFlags & CHN_FILTER) ? false : true);
 			#endif // NO_FILTER
 			}
 			break;
@@ -3044,13 +3048,22 @@
 			pChn->nPos += param;
 		if (pChn->nPos >= pChn->nLength)
 		{
+			// Offset beyond sample size
 			if (!(m_nType & (MOD_TYPE_XM|MOD_TYPE_MT2)))
 			{
-				pChn->nPos = pChn->nLoopStart;
+				if(IsCompatibleMode(TRK_IMPULSETRACKER))
+					pChn->nPos = 0; // IT Compatibility: Reset to beginning of sample
+				else
+					pChn->nPos = pChn->nLoopStart;
 				if ((m_dwSongFlags & SONG_ITOLDEFFECTS) && (pChn->nLength > 4))
 				{
 					pChn->nPos = pChn->nLength - 2;
 				}
+			} else if(IsCompatibleMode(TRK_FASTTRACKER2))
+			{
+				// XM Compatibility: Don't play note
+				pChn->dwFlags |= CHN_FASTVOLRAMP;
+				pChn->nVolume = pChn->nPeriod = 0;
 			}
 		}
 	} else
@@ -3139,7 +3152,7 @@
 			if ((pChn->nRowInstr) && (param < 0x100)) { InstrumentChange(pChn, pChn->nRowInstr, FALSE, FALSE); bResetEnv = TRUE; }
 			if (param < 0x100) bResetEnv = TRUE;
 		}
-		NoteChange(nChn, nNote, FALSE, bResetEnv);
+		NoteChange(nChn, nNote, false, bResetEnv);
 		if (m_nInstruments) {
 			ProcessMidiOut(nChn, pChn);	//Send retrig to Midi
 		}

Modified: trunk/OpenMPT/soundlib/Sndfile.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Sndfile.cpp	2009-09-11 19:32:52 UTC (rev 361)
+++ trunk/OpenMPT/soundlib/Sndfile.cpp	2009-09-13 13:44:24 UTC (rev 362)
@@ -806,7 +806,7 @@
 		if (pSmp->pSample)
 		{
 			FreeSample(pSmp->pSample);
-			pSmp->pSample = NULL;
+			pSmp->pSample = nullptr;
 		}
 	}
 	for (i=0; i<MAX_INSTRUMENTS; i++)
@@ -1449,8 +1449,8 @@
 	if(resetMask & 2)
 	{
 		Chn[i].nNote = Chn[i].nNewNote = Chn[i].nNewIns = 0;
-		Chn[i].pModSample = NULL;
-		Chn[i].pModInstrument = NULL;
+		Chn[i].pModSample = nullptr;
+		Chn[i].pModInstrument = nullptr;
 		Chn[i].nPortamentoDest = 0;
 		Chn[i].nCommand = 0;
 		Chn[i].nPatternLoopCount = 0;
@@ -1473,9 +1473,9 @@
 		Chn[i].nLoopStart = 0;
 		Chn[i].nLoopEnd = 0;
 		Chn[i].nROfs = Chn[i].nLOfs = 0;
-		Chn[i].pSample = NULL;
-		Chn[i].pModSample = NULL;
-		Chn[i].pModInstrument = NULL;
+		Chn[i].pSample = nullptr;
+		Chn[i].pModSample = nullptr;
+		Chn[i].pModInstrument = nullptr;
 		Chn[i].nCutOff = 0x7F;
 		Chn[i].nResonance = 0;
 		Chn[i].nFilterMode = 0;
@@ -2001,7 +2001,7 @@
 	{
 		pSmp->nLength = 0;
 		FreeSample(pSmp->pSample);
-		pSmp->pSample = NULL;
+		pSmp->pSample = nullptr;
 		MessageBox(0, str_SampleAllocationError, str_Error, MB_ICONERROR);
 		return 0;
 	}
@@ -2438,7 +2438,7 @@
 		{
 			pSmp->nLength = 0;
 			FreeSample(pSmp->pSample);
-			pSmp->pSample = NULL;
+			pSmp->pSample = nullptr;
 		}
 		return 0;
 	}
@@ -2766,7 +2766,7 @@
 	if (!Samples[nSample].pSample) return TRUE;
 	MODSAMPLE *pSmp = &Samples[nSample];
 	LPSTR pSample = pSmp->pSample;
-	pSmp->pSample = NULL;
+	pSmp->pSample = nullptr;
 	pSmp->nLength = 0;
 	pSmp->uFlags &= ~(CHN_16BIT);
 	for (UINT i=0; i<MAX_CHANNELS; i++)

Modified: trunk/OpenMPT/soundlib/Sndfile.h
===================================================================
--- trunk/OpenMPT/soundlib/Sndfile.h	2009-09-11 19:32:52 UTC (rev 361)
+++ trunk/OpenMPT/soundlib/Sndfile.h	2009-09-13 13:44:24 UTC (rev 362)
@@ -796,7 +796,7 @@
 	BOOL ProcessEffects();
 	UINT GetNNAChannel(UINT nChn) const;
 	void CheckNNA(UINT nChn, UINT instr, int note, BOOL bForceCut);
-	void NoteChange(UINT nChn, int note, BOOL bPorta=FALSE, BOOL bResetEnv=TRUE, BOOL bManual=FALSE);
+	void NoteChange(UINT nChn, int note, bool bPorta = false, bool bResetEnv = true, bool bManual = false);
 	void InstrumentChange(MODCHANNEL *pChn, UINT instr, BOOL bPorta=FALSE,BOOL bUpdVol=TRUE,BOOL bResetEnv=TRUE);
 
 	// Channel Effects
@@ -834,7 +834,7 @@
 	void ExtendedChannelEffect(MODCHANNEL *, UINT param);
 	void ProcessMidiMacro(UINT nChn, LPCSTR pszMidiMacro, UINT param=0);
 	void ProcessSmoothMidiMacro(UINT nChn, LPCSTR pszMidiMacro, UINT param=0); //rewbs.smoothVST
-	void SetupChannelFilter(MODCHANNEL *pChn, BOOL bReset, int flt_modifier=256) const;
+	void SetupChannelFilter(MODCHANNEL *pChn, bool bReset, int flt_modifier = 256) const;
 	// Low-Level effect processing
 	void DoFreqSlide(MODCHANNEL *pChn, LONG nFreqSlide);
 	void GlobalVolSlide(UINT param, UINT * nOldGlobalVolSlide);

Modified: trunk/OpenMPT/soundlib/Sndmix.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Sndmix.cpp	2009-09-11 19:32:52 UTC (rev 361)
+++ trunk/OpenMPT/soundlib/Sndmix.cpp	2009-09-13 13:44:24 UTC (rev 362)
@@ -698,9 +698,9 @@
 									Chn[i].dwFlags = ChnSettings[i].dwFlags;
 									Chn[i].nLoopStart = 0;
 									Chn[i].nLoopEnd = 0;
-									Chn[i].pModInstrument = NULL;
-									Chn[i].pSample = NULL;
-									Chn[i].pModSample = NULL;
+									Chn[i].pModInstrument = nullptr;
+									Chn[i].pSample = nullptr;
+									Chn[i].pModSample = nullptr;
 								}
 							}
 						}
@@ -1302,7 +1302,7 @@
 				if (pIns->dwFlags & ENV_FILTER)
 				{
 #ifndef NO_FILTER
-					SetupChannelFilter(pChn, (pChn->dwFlags & CHN_FILTER) ? FALSE : TRUE, envpitch);
+					SetupChannelFilter(pChn, (pChn->dwFlags & CHN_FILTER) ? false : true, envpitch);
 #endif // NO_FILTER
 				} else
 				// Pitch Envelope


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-09-11 19:33:12

Revision: 361
          http://modplug.svn.sourceforge.net/modplug/?rev=361&view=rev
Author:   saga-games
Date:     2009-09-11 19:32:52 +0000 (Fri, 11 Sep 2009)

Log Message:
-----------
[Fix] MPTM Saving: Save Note Fade (~~) properly
[Fix] Mod Conversion: Unset release nodes were corrupted when converting modules

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/Modedit.cpp
    trunk/OpenMPT/soundlib/Load_it.cpp

Modified: trunk/OpenMPT/mptrack/Modedit.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Modedit.cpp	2009-09-10 21:00:57 UTC (rev 360)
+++ trunk/OpenMPT/mptrack/Modedit.cpp	2009-09-11 19:32:52 UTC (rev 361)
@@ -778,7 +778,7 @@
 	TRIMENV(mptEnv->nLoopEnd);
 	TRIMENV(mptEnv->nSustainStart);
 	TRIMENV(mptEnv->nSustainEnd);
-	TRIMENV(mptEnv->nReleaseNode);
+	if(mptEnv->nReleaseNode != ENV_RELEASE_NODE_UNSET) TRIMENV(mptEnv->nReleaseNode);
 
 	#undef TRIMENV
 

Modified: trunk/OpenMPT/soundlib/Load_it.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_it.cpp	2009-09-10 21:00:57 UTC (rev 360)
+++ trunk/OpenMPT/soundlib/Load_it.cpp	2009-09-11 19:32:52 UTC (rev 361)
@@ -2190,7 +2190,7 @@
 				UINT note = m->note;
 				if (note) b |= 1;
 				if ((note) && (note < NOTE_MIN_SPECIAL)) note--;
-				if (note == NOTE_FADE) note = 0xF6;
+				if (note == NOTE_FADE && GetType() != MOD_TYPE_MPT) note = 0xF6;
 				if (m->instr) b |= 2;
 				if (m->volcmd)
 				{


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-09-10 21:01:07

Revision: 360
          http://modplug.svn.sourceforge.net/modplug/?rev=360&view=rev
Author:   saga-games
Date:     2009-09-10 21:00:57 +0000 (Thu, 10 Sep 2009)

Log Message:
-----------
[Fix] Instrument Tab: Proper limits for IT/XM fadeout values
[Fix] XM / IT Saver: Limit fadeout values properly
[Imp] IT Compatibility Export: Removed stereo sample support
[Imp] Updated DE_jojo.mkb keymap (added Save As command)
[Imp] Updated IT Mod Specifications
[Imp] Comments tab: Usage of existing sample size + bit depth functions to calculate information
[Imp] XM Loader: Advanced "made with MPT" detection

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/Ctrl_ins.cpp
    trunk/OpenMPT/mptrack/Modedit.cpp
    trunk/OpenMPT/mptrack/view_com.cpp
    trunk/OpenMPT/packageTemplate/extraKeymaps/DE_jojo.mkb
    trunk/OpenMPT/soundlib/Load_it.cpp
    trunk/OpenMPT/soundlib/Load_xm.cpp
    trunk/OpenMPT/soundlib/mod_specifications.h

Modified: trunk/OpenMPT/mptrack/Ctrl_ins.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_ins.cpp	2009-09-10 13:31:37 UTC (rev 359)
+++ trunk/OpenMPT/mptrack/Ctrl_ins.cpp	2009-09-10 21:00:57 UTC (rev 360)
@@ -801,7 +801,7 @@
 	m_ComboDCA.AddString("Note Off");
 	m_ComboDCA.AddString("Note Fade");
 	// FadeOut Volume
-	m_SpinFadeOut.SetRange(0, 32000);
+	m_SpinFadeOut.SetRange(0, 8192);
 	// Global Volume
 	m_SpinGlobalVol.SetRange(0, 64);
 	// Panning
@@ -1072,7 +1072,13 @@
 		m_SpinMidiPR.EnableWindow(bITandXM);
 		m_SpinMidiBK.EnableWindow(bITandXM);	//rewbs.MidiBank
 		//end rewbs.instroVSTi
+
 		m_SpinFadeOut.EnableWindow(bITandXM);
+		if(m_pSndFile->m_nType & MOD_TYPE_XM)
+			m_SpinFadeOut.SetRange(0, 4095);
+		else
+			m_SpinFadeOut.SetRange(0, 8192);
+
 		m_NoteMap.EnableWindow(bITandXM);
 		m_CbnResampling.EnableWindow(bITandXM);
 		

Modified: trunk/OpenMPT/mptrack/Modedit.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Modedit.cpp	2009-09-10 13:31:37 UTC (rev 359)
+++ trunk/OpenMPT/mptrack/Modedit.cpp	2009-09-10 21:00:57 UTC (rev 360)
@@ -768,7 +768,7 @@
 //-------------------------------------------------------
 {
 	// shorten instrument envelope if necessary (for mod conversion)
-	const int iEnvMax = m_SndFile.GetModSpecifications().envelopePointsMax;
+	const UINT iEnvMax = m_SndFile.GetModSpecifications().envelopePointsMax;
 	bool bResult = false;
 
 	#define TRIMENV(i) if(i > iEnvMax) {i = iEnvMax; bResult = true;}

Modified: trunk/OpenMPT/mptrack/view_com.cpp
===================================================================
--- trunk/OpenMPT/mptrack/view_com.cpp	2009-09-10 13:31:37 UTC (rev 359)
+++ trunk/OpenMPT/mptrack/view_com.cpp	2009-09-10 21:00:57 UTC (rev 360)
@@ -252,15 +252,13 @@
 					case SMPLIST_SIZE:
 						if (pSmp->nLength)
 						{
-							UINT nShift = (pSmp->uFlags & CHN_16BIT) ? 9 : 10;
-							if (pSmp->uFlags & CHN_STEREO) nShift--;
-							wsprintf(s, "%d KB", pSmp->nLength >> nShift);
+							wsprintf(s, "%d KB", pSmp->GetSampleSizeInBytes() >> 10);
 						}
 						break;
 					case SMPLIST_TYPE:
 						if (pSmp->nLength)
 						{
-							strcpy(s, (pSmp->uFlags & CHN_16BIT) ? "16 Bit" : "8 Bit");
+							wsprintf(s, "%d Bit", pSmp->GetElementarySampleSize() << 3);
 						}
 						break;
 					case SMPLIST_INSTR:

Modified: trunk/OpenMPT/packageTemplate/extraKeymaps/DE_jojo.mkb
===================================================================
--- trunk/OpenMPT/packageTemplate/extraKeymaps/DE_jojo.mkb	2009-09-10 13:31:37 UTC (rev 359)
+++ trunk/OpenMPT/packageTemplate/extraKeymaps/DE_jojo.mkb	2009-09-10 21:00:57 UTC (rev 360)
@@ -8,6 +8,7 @@
 0:1346:2:79:1		//File/Open: Ctrl+O (KeyDown)
 0:1348:2:87:5		//File/Close: Ctrl+W (KeyDown|KeyHold)
 0:1349:2:83:1		//File/Save: Ctrl+S (KeyDown)
+0:1350:3:83:1		//File/Save As: Shift+Ctrl+S (KeyDown)
 0:1693:0:166:1		//Previous Document:  (KeyDown)
 0:1694:0:167:1		//Next Document:  (KeyDown)
 0:1030:0:116:1		//Play song/Pause song: F5 (KeyDown)

Modified: trunk/OpenMPT/soundlib/Load_it.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_it.cpp	2009-09-10 13:31:37 UTC (rev 359)
+++ trunk/OpenMPT/soundlib/Load_it.cpp	2009-09-10 21:00:57 UTC (rev 360)
@@ -301,7 +301,7 @@
 		}
 		if (pis->mbank<=128)
 			pIns->wMidiBank = pis->mbank;
-		pIns->nFadeOut = pis->fadeout << 5; // should be 6?
+		pIns->nFadeOut = pis->fadeout << 5;
 		pIns->nGlobalVol = pis->gbv >> 1;
 		if (pIns->nGlobalVol > 64) pIns->nGlobalVol = 64;
 		for (UINT j = 0; j < 120; j++)
@@ -2003,7 +2003,7 @@
 			//if (pIns->nDCT<DCT_PLUGIN) iti.dct = pIns->nDCT; else iti.dct =0;	
 			iti.dct = pIns->nDCT; //rewbs.instroVSTi: will other apps barf if they get an unknown DCT?
 			iti.dca = pIns->nDNA;
-			iti.fadeout = pIns->nFadeOut >> 5; // should be 6?
+			iti.fadeout = min(pIns->nFadeOut >> 5 , 256);
 			iti.pps = pIns->nPPS;
 			iti.ppc = pIns->nPPC;
 			iti.gbv = (BYTE)(pIns->nGlobalVol << 1);
@@ -2648,7 +2648,7 @@
 			iti.nna = pIns->nNNA;
 			if (pIns->nDCT<DCT_PLUGIN) iti.dct = pIns->nDCT; else iti.dct =0;	
 			iti.dca = pIns->nDNA;
-			iti.fadeout = pIns->nFadeOut >> 5;
+			iti.fadeout = min(pIns->nFadeOut >> 5 , 256);
 			iti.pps = pIns->nPPS;
 			iti.ppc = pIns->nPPC;
 			iti.gbv = (BYTE)(pIns->nGlobalVol << 1);
@@ -2991,30 +2991,10 @@
 		if (psmp->uFlags & CHN_PANNING) itss.dfp |= 0x80;
 		if ((psmp->pSample) && (psmp->nLength)) itss.cvt = 0x01;
 		UINT flags = RS_PCM8S;
-		/*
-#ifndef NO_PACKING
-		if (nPacking)
+		if (psmp->uFlags & CHN_16BIT)
 		{
-			if ((!(psmp->uFlags & (CHN_16BIT|CHN_STEREO)))
-			 && (CanPackSample(psmp->pSample, psmp->nLength, nPacking)))
-			{
-				flags = RS_ADPCM4;
-				itss.cvt = 0xFF;
-			}
-		} else
-#endif // NO_PACKING
-		*/
-		{
-			if (psmp->uFlags & CHN_STEREO)
-			{
-				flags = RS_STPCM8S;
-				itss.flags |= 0x04;
-			}
-			if (psmp->uFlags & CHN_16BIT)
-			{
-				itss.flags |= 0x02;
-				flags = (psmp->uFlags & CHN_STEREO) ? RS_STPCM16S : RS_PCM16S;
-			}
+			itss.flags |= 0x02;
+			flags = RS_PCM16S;
 		}
 		itss.samplepointer = dwPos;
 		fseek(f, smppos[nsmp-1], SEEK_SET);

Modified: trunk/OpenMPT/soundlib/Load_xm.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_xm.cpp	2009-09-10 13:31:37 UTC (rev 359)
+++ trunk/OpenMPT/soundlib/Load_xm.cpp	2009-09-10 21:00:57 UTC (rev 360)
@@ -119,22 +119,6 @@
 	if ((!channels) || (channels > MAX_BASECHANNELS)) return false;
 // -! BEHAVIOUR_CHANGE#0006
 
-	if (!memcmp((LPCSTR)lpStream + 0x26, "FastTracker v2.00   ", 20) && bProbablyMadeWithModPlug) bMadeWithModPlug = true;
-	if (!memcmp((LPCSTR)lpStream + 0x26, "FastTracker v 2.00  ", 20))
-	{
-		bMadeWithModPlug = true;
-		m_dwLastSavedWithVersion = MAKE_VERSION_NUMERIC(1, 00, 00, 00);
-	}
-
-	if (!memcmp((LPCSTR)lpStream + 0x26, "OpenMPT ", 8))
-	{
-		//bMadeWithModPlug = true; // Don't set it - it's also used by compatibility export
-		CHAR sVersion[13];
-		memcpy(sVersion, lpStream + 0x26 + 8, 12);
-		sVersion[12] = 0;
-		m_dwLastSavedWithVersion = MptVersion::ToNum(sVersion);
-	}
-
 	m_nType = MOD_TYPE_XM;
 	m_nMinPeriod = 27;
 	m_nMaxPeriod = 54784;
@@ -334,7 +318,10 @@
 		Instruments[iIns]->nPluginVolumeHandling = PLUGIN_VOLUMEHANDLING_IGNORE;
 
 		memcpy(Instruments[iIns]->name, pih->name, 22);
-				
+		// look for null-terminated instr name - that's most likely a tune made with modplug
+		for(int i = 0; i < 22; i++)
+			if(pih->name[i] == 0) bProbablyMadeWithModPlug = true;
+
 		if ((nsamples = pih->samples) > 0)
 		{
 			/* we have samples, so let's read the rest of this instrument
@@ -560,6 +547,9 @@
 			pSmp->nVibRate = xmsh.vibrate;
 			memcpy(pSmp->filename, xmss.name, 22);
 			pSmp->filename[21] = 0;
+			// look for null-terminated sample name - that's most likely a tune made with modplug
+			for(int i = 0; i < 22; i++)
+				if(xmss.name[i] == 0) bProbablyMadeWithModPlug = true;
 		}
 #if 0
 		if ((xmsh.reserved2 > nsamples) && (xmsh.reserved2 <= 16))
@@ -648,6 +638,25 @@
 		bMadeWithModPlug = true;
 	}
 
+	// Check various things to find out whether this has been made with MPT.
+	// Null chars in names -> most likely made with MPT, which disguises as FT2
+	if (!memcmp((LPCSTR)lpStream + 0x26, "FastTracker v2.00   ", 20) && bProbablyMadeWithModPlug) bMadeWithModPlug = true;
+	if (!memcmp((LPCSTR)lpStream + 0x26, "FastTracker v 2.00  ", 20))
+	{
+		// Early MPT 1.0 alpha/beta versions
+		bMadeWithModPlug = true;
+		m_dwLastSavedWithVersion = MAKE_VERSION_NUMERIC(1, 00, 00, 00);
+	}
+
+	if (!memcmp((LPCSTR)lpStream + 0x26, "OpenMPT ", 8))
+	{
+		//bMadeWithModPlug = true; // Don't set it - it's also used by compatibility export
+		CHAR sVersion[13];
+		memcpy(sVersion, lpStream + 0x26 + 8, 12);
+		sVersion[12] = 0;
+		m_dwLastSavedWithVersion = MptVersion::ToNum(sVersion);
+	}
+
 	if(bMadeWithModPlug)
 	{
 		SetModFlag(MSF_COMPATIBLE_PLAY, false);
@@ -862,7 +871,7 @@
 			{
 				memcpy(xmih.name, pIns->name, 22);
 				xmih.type = pIns->nMidiProgram;
-				xmsh.volfade = pIns->nFadeOut;
+				xmsh.volfade = min(pIns->nFadeOut, 0xFFF); // FFF is maximum in FT2
 				xmsh.vnum = (BYTE)pIns->VolEnv.nNodes;
 				xmsh.pnum = (BYTE)pIns->PanEnv.nNodes;
 				if (xmsh.vnum > 12) xmsh.vnum = 12;

Modified: trunk/OpenMPT/soundlib/mod_specifications.h
===================================================================
--- trunk/OpenMPT/soundlib/mod_specifications.h	2009-09-10 13:31:37 UTC (rev 359)
+++ trunk/OpenMPT/soundlib/mod_specifications.h	2009-09-10 21:00:57 UTC (rev 360)
@@ -33,10 +33,10 @@
 	INSTRUMENTINDEX instrumentsMax;
 	BYTE defaultMixLevels;
 	BYTE MIDIMappingDirectivesMax;
-	UINT speedMin;
-	UINT speedMax;
-	bool hasComments;
-	int envelopePointsMax;
+	UINT speedMin;			// Minimum ticks per frame
+	UINT speedMax;			// Maximum ticks per frame
+	bool hasComments;		// True if format has a comments field
+	UINT envelopePointsMax;	// Maximum number of points of each envelope
 };
 
 
@@ -103,7 +103,7 @@
 	1,									//Min Speed
 	31,									//Max Speed
 	false,								//No song comments
-	0,									//Envelope point count
+	0,									//No instrument envelopes
 };
 
 // MOD with MPT extensions.
@@ -132,7 +132,7 @@
 	1,									//Min Speed
 	31,									//Max Speed
 	false,								//No song comments
-	0,									//Envelope point count
+	0,									//No instrument envelopes
 };
 
 const CModSpecifications xm =
@@ -216,7 +216,7 @@
 	1,									//Min Speed
 	255,								//Max Speed
 	false,								//No song comments
-	0,									//Envelope point count
+	0,									//No instrument envelopes
 };
 
 // S3M with MPT extensions
@@ -245,7 +245,7 @@
 	1,									//Min Speed
 	255,								//Max Speed
 	false,								//No song comments
-	0,									//Envelope point count
+	0,									//No instrument envelopes
 };
 
 const CModSpecifications it =
@@ -266,8 +266,8 @@
 	1,									//Min pattern rows
 	256,								//Max pattern rows
     25,									//Max mod name length
-	256,								//SamplesMax
-	200,								//instrumentMax
+	99,									//SamplesMax
+	99,									//instrumentMax
 	mixLevels_original,					//defaultMixLevels
 	0,									//Max MIDI mapping directives
 	1,									//Min Speed


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-09-10 13:31:46

Revision: 359
          http://modplug.svn.sourceforge.net/modplug/?rev=359&view=rev
Author:   saga-games
Date:     2009-09-10 13:31:37 +0000 (Thu, 10 Sep 2009)

Log Message:
-----------
[Fix] Instrument editor: Can now also copy long MPTM envelopes
[Ref] Make use of the new envelope struct in envelope c&p and scale env points code

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/Modedit.cpp
    trunk/OpenMPT/mptrack/ScaleEnvPointsDlg.cpp

Modified: trunk/OpenMPT/mptrack/Modedit.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Modedit.cpp	2009-09-09 23:14:18 UTC (rev 358)
+++ trunk/OpenMPT/mptrack/Modedit.cpp	2009-09-10 13:31:37 UTC (rev 359)
@@ -2388,71 +2388,51 @@
 {
 	CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
 	HANDLE hCpy;
-	CHAR s[1024];
+	CHAR s[4096];
 	MODINSTRUMENT *pIns;
 	DWORD dwMemSize;
-	UINT susBegin, susEnd, loopBegin, loopEnd, bSus, bLoop, bCarry, nPoints, releaseNode;
-	WORD *pPoints;
-	BYTE *pValues;
+	UINT bSus, bLoop, bCarry;
 
 	if ((nIns < 1) || (nIns > m_SndFile.m_nInstruments) || (!m_SndFile.Instruments[nIns]) || (!pMainFrm)) return FALSE;
 	BeginWaitCursor();
 	pIns = m_SndFile.Instruments[nIns];
+	
+	INSTRUMENTENVELOPE *pEnv = nullptr;
+
 	switch(nEnv)
 	{
 	case ENV_PANNING:
-		pPoints = pIns->PanEnv.Ticks;
-		pValues = pIns->PanEnv.Values;
-		nPoints = pIns->PanEnv.nNodes;
-		bLoop = (pIns->dwFlags & ENV_PANLOOP) ? TRUE : FALSE;
-		bSus = (pIns->dwFlags & ENV_PANSUSTAIN) ? TRUE : FALSE;
-		bCarry = (pIns->dwFlags & ENV_PANCARRY) ? TRUE : FALSE;
-		susBegin = pIns->PanEnv.nSustainStart;
-		susEnd = pIns->PanEnv.nSustainEnd;
-		loopBegin = pIns->PanEnv.nLoopStart;
-		loopEnd = pIns->PanEnv.nLoopEnd;
-		releaseNode = pIns->PanEnv.nReleaseNode;
+		pEnv = &pIns->PanEnv;
+		bLoop = (pIns->dwFlags & ENV_PANLOOP) ? 1 : 0;
+		bSus = (pIns->dwFlags & ENV_PANSUSTAIN) ? 1 : 0;
+		bCarry = (pIns->dwFlags & ENV_PANCARRY) ? 1 : 0;
 		break;
 
 	case ENV_PITCH:
-		pPoints = pIns->PitchEnv.Ticks;
-		pValues = pIns->PitchEnv.Values;
-		nPoints = pIns->PitchEnv.nNodes;
-		bLoop = (pIns->dwFlags & ENV_PITCHLOOP) ? TRUE : FALSE;
-		bSus = (pIns->dwFlags & ENV_PITCHSUSTAIN) ? TRUE : FALSE;
-		bCarry = (pIns->dwFlags & ENV_PITCHCARRY) ? TRUE : FALSE;
-		susBegin = pIns->PitchEnv.nSustainStart;
-		susEnd = pIns->PitchEnv.nSustainEnd;
-		loopBegin = pIns->PitchEnv.nLoopStart;
-		loopEnd = pIns->PitchEnv.nLoopEnd;
-		releaseNode = pIns->PitchEnv.nReleaseNode;
+		pEnv = &pIns->PitchEnv;
+		bLoop = (pIns->dwFlags & ENV_PITCHLOOP) ? 1 : 0;
+		bSus = (pIns->dwFlags & ENV_PITCHSUSTAIN) ? 1 : 0;
+		bCarry = (pIns->dwFlags & ENV_PITCHCARRY) ? 1 : 0;
 		break;
 
 	default:
-		pPoints = pIns->VolEnv.Ticks;
-		pValues = pIns->VolEnv.Values;
-		nPoints = pIns->VolEnv.nNodes;
-		bLoop = (pIns->dwFlags & ENV_VOLLOOP) ? TRUE : FALSE;
-		bSus = (pIns->dwFlags & ENV_VOLSUSTAIN) ? TRUE : FALSE;
-		bCarry = (pIns->dwFlags & ENV_VOLCARRY) ? TRUE : FALSE;
-		susBegin = pIns->VolEnv.nSustainStart;
-		susEnd = pIns->VolEnv.nSustainEnd;
-		loopBegin = pIns->VolEnv.nLoopStart;
-		loopEnd = pIns->VolEnv.nLoopEnd;
-		releaseNode = pIns->VolEnv.nReleaseNode;
+		pEnv = &pIns->VolEnv;
+		bLoop = (pIns->dwFlags & ENV_VOLLOOP) ? 1 : 0;
+		bSus = (pIns->dwFlags & ENV_VOLSUSTAIN) ? 1 : 0;
+		bCarry = (pIns->dwFlags & ENV_VOLCARRY) ? 1 : 0;
 		break;
 	}
 	strcpy(s, pszEnvHdr);
-	wsprintf(s+strlen(s), pszEnvFmt, nPoints, susBegin, susEnd, loopBegin, loopEnd, bSus, bLoop, bCarry);
-	for (UINT i=0; i<nPoints; i++)
+	wsprintf(s + strlen(s), pszEnvFmt, pEnv->nNodes, pEnv->nSustainStart, pEnv->nSustainEnd, pEnv->nLoopStart, pEnv->nLoopEnd, bSus, bLoop, bCarry);
+	for (UINT i = 0; i < pEnv->nNodes; i++)
 	{
 		if (strlen(s) >= sizeof(s)-32) break;
-		wsprintf(s+strlen(s), "%d,%d\x0D\x0A", pPoints[i], pValues[i]);
+		wsprintf(s+strlen(s), "%d,%d\x0D\x0A", pEnv->Ticks[i], pEnv->Values[i]);
 	}
 
 	//Writing release node
 	if(strlen(s) < sizeof(s) - 32)
-		wsprintf(s+strlen(s), "%u\x0D\x0A", releaseNode);
+		wsprintf(s+strlen(s), "%u\x0D\x0A", pEnv->nReleaseNode);
 
 	dwMemSize = strlen(s)+1;
 	if ((pMainFrm->OpenClipboard()) && ((hCpy = GlobalAlloc(GMEM_MOVEABLE|GMEM_DDESHARE, dwMemSize))!=NULL))
@@ -2486,6 +2466,8 @@
 	if ((hCpy) && ((p = (LPSTR)GlobalLock(hCpy)) != NULL))
 	{
 		MODINSTRUMENT *pIns = m_SndFile.Instruments[nIns];
+		INSTRUMENTENVELOPE *pEnv = nullptr;
+
 		UINT susBegin=0, susEnd=0, loopBegin=0, loopEnd=0, bSus=0, bLoop=0, bCarry=0, nPoints=0, releaseNode = ENV_RELEASE_NODE_UNSET;
 		DWORD dwMemSize = GlobalSize(hCpy), dwPos = strlen(pszEnvHdr);
 		if ((dwMemSize > dwPos) && (!_strnicmp(p, pszEnvHdr, dwPos-2)))
@@ -2508,60 +2490,45 @@
 				}
 				while ((dwPos < dwMemSize) && ((p[dwPos] >= '0') && (p[dwPos] <= '9'))) dwPos++;
 			}
-			if (nPoints > 31) nPoints = 31;
+			nPoints = min(nPoints, m_SndFile.GetModSpecifications().envelopePointsMax);
 			if (susEnd >= nPoints) susEnd = 0;
 			if (susBegin > susEnd) susBegin = susEnd;
 			if (loopEnd >= nPoints) loopEnd = 0;
 			if (loopBegin > loopEnd) loopBegin = loopEnd;
-			WORD *pPoints;
-			BYTE *pValues;
+
 			switch(nEnv)
 			{
 			case ENV_PANNING:
-				pPoints = pIns->PanEnv.Ticks;
-				pValues = pIns->PanEnv.Values;
-				pIns->PanEnv.nNodes = nPoints;
+				pEnv = &pIns->PanEnv;
 				pIns->dwFlags &= ~(ENV_PANLOOP|ENV_PANSUSTAIN|ENV_PANCARRY);
 				if (bLoop) pIns->dwFlags |= ENV_PANLOOP;
 				if (bSus) pIns->dwFlags |= ENV_PANSUSTAIN;
 				if (bCarry) pIns->dwFlags |= ENV_PANCARRY;
-				pIns->PanEnv.nSustainStart = susBegin;
-				pIns->PanEnv.nSustainEnd = susEnd;
-				pIns->PanEnv.nLoopStart = loopBegin;
-				pIns->PanEnv.nLoopEnd = loopEnd;
-				pIns->PanEnv.nReleaseNode = releaseNode;
 				break;
 
 			case ENV_PITCH:
-				pPoints = pIns->PitchEnv.Ticks;
-				pValues = pIns->PitchEnv.Values;
-				pIns->PitchEnv.nNodes = nPoints;
+				pEnv = &pIns->PitchEnv;
 				pIns->dwFlags &= ~(ENV_PITCHLOOP|ENV_PITCHSUSTAIN|ENV_PITCHCARRY);
 				if (bLoop) pIns->dwFlags |= ENV_PITCHLOOP;
 				if (bSus) pIns->dwFlags |= ENV_PITCHSUSTAIN;
 				if (bCarry) pIns->dwFlags |= ENV_PITCHCARRY;
-				pIns->PitchEnv.nSustainStart = susBegin;
-				pIns->PitchEnv.nSustainEnd = susEnd;
-				pIns->PitchEnv.nLoopStart = loopBegin;
-				pIns->PitchEnv.nLoopEnd = loopEnd;
-				pIns->PitchEnv.nReleaseNode = releaseNode;
 				break;
 
 			default:
-				pPoints = pIns->VolEnv.Ticks;
-				pValues = pIns->VolEnv.Values;
-				pIns->VolEnv.nNodes = nPoints;
+				pEnv = &pIns->VolEnv;
 				pIns->dwFlags &= ~(ENV_VOLLOOP|ENV_VOLSUSTAIN|ENV_VOLCARRY);
 				if (bLoop) pIns->dwFlags |= ENV_VOLLOOP;
 				if (bSus) pIns->dwFlags |= ENV_VOLSUSTAIN;
 				if (bCarry) pIns->dwFlags |= ENV_VOLCARRY;
-				pIns->VolEnv.nSustainStart = susBegin;
-				pIns->VolEnv.nSustainEnd = susEnd;
-				pIns->VolEnv.nLoopStart = loopBegin;
-				pIns->VolEnv.nLoopEnd = loopEnd;
-				pIns->VolEnv.nReleaseNode = releaseNode;
 				break;
 			}
+			pEnv->nNodes = nPoints;
+			pEnv->nSustainStart = susBegin;
+			pEnv->nSustainEnd = susEnd;
+			pEnv->nLoopStart = loopBegin;
+			pEnv->nLoopEnd = loopEnd;
+			pEnv->nReleaseNode = releaseNode;
+
 			int oldn = 0;
 			for (UINT i=0; i<nPoints; i++)
 			{
@@ -2573,8 +2540,8 @@
 				if (dwPos >= dwMemSize) break;
 				int n2 = atoi(p+dwPos);
 				if ((n1 < oldn) || (n1 > 0x3FFF)) n1 = oldn+1;
-				pPoints[i] = (WORD)n1;
-				pValues[i] = (BYTE)n2;
+				pEnv->Ticks[i] = (WORD)n1;
+				pEnv->Values[i] = (BYTE)n2;
 				oldn = n1;
 				while ((dwPos < dwMemSize) && (p[dwPos] != 0x0D)) dwPos++;
 				if (dwPos >= dwMemSize) break;
@@ -2585,20 +2552,7 @@
 			{
 				BYTE r = static_cast<BYTE>(atoi(p + dwPos));
 				if(r == 0 || r >= nPoints) r = ENV_RELEASE_NODE_UNSET;
-				switch(nEnv)
-				{
-					case ENV_PANNING:
-						pIns->PanEnv.nReleaseNode = r;
-					break;
-
-					case ENV_PITCH:
-						pIns->PitchEnv.nReleaseNode = r;
-					break;
-
-					default:
-						pIns->VolEnv.nReleaseNode = r;
-					break;
-				}
+				pEnv->nReleaseNode = r;
 			}
 		}
 		GlobalUnlock(hCpy);

Modified: trunk/OpenMPT/mptrack/ScaleEnvPointsDlg.cpp
===================================================================
--- trunk/OpenMPT/mptrack/ScaleEnvPointsDlg.cpp	2009-09-09 23:14:18 UTC (rev 358)
+++ trunk/OpenMPT/mptrack/ScaleEnvPointsDlg.cpp	2009-09-10 13:31:37 UTC (rev 359)
@@ -45,36 +45,20 @@
 	float factor = ConvertStrTo<float>(buffer);
 	if(factor > 0)
 	{
-		WORD (*array)[MAX_ENVPOINTS] = NULL;
-		UINT* arraySize = NULL;
+		INSTRUMENTENVELOPE *pEnv = nullptr;
 		switch(m_Env)
 		{
-			case ENV_VOLUME:
-				array = &m_pInstrument->VolEnv.Ticks;
-				arraySize = &m_pInstrument->VolEnv.nNodes;
-			break;
-
-			case ENV_PANNING:
-				array = &m_pInstrument->PanEnv.Ticks;
-				arraySize = &m_pInstrument->PanEnv.nNodes;
-			break;
-
-			case ENV_PITCH:
-				array = &m_pInstrument->PitchEnv.Ticks;
-				arraySize = &m_pInstrument->PitchEnv.nNodes;
-			break;
+			case ENV_PANNING:	pEnv = &m_pInstrument->PanEnv;		break;
+			case ENV_PITCH:		pEnv = &m_pInstrument->PitchEnv;	break;
+			default:			pEnv = &m_pInstrument->VolEnv;		break;
 		}
-
-		if(array && arraySize)
+		for(UINT i = 0; i< pEnv->nNodes; i++)
 		{
-			for(UINT i = 0; i<*arraySize; i++)
-			{
-				(*array)[i] = static_cast<WORD>(factor * (*array)[i]);
+			pEnv->Ticks[i] = static_cast<WORD>(factor * pEnv->Ticks[i]);
 
-				//Checking that the order of points is preserved.
-				if(i > 0 && (*array)[i] <= (*array)[i-1])
-					(*array)[i] = (*array)[i-1]+1;
-			}
+			//Checking that the order of points is preserved.
+			if(i > 0 && pEnv->Ticks[i] <= pEnv->Ticks[i - 1])
+				pEnv->Ticks[i] = pEnv->Ticks[i - 1] + 1;
 		}
 	}
 


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-09-09 23:14:33

Revision: 358
          http://modplug.svn.sourceforge.net/modplug/?rev=358&view=rev
Author:   saga-games
Date:     2009-09-09 23:14:18 +0000 (Wed, 09 Sep 2009)

Log Message:
-----------
[Imp] Mod Conversion: Trim instrument envelopes if they're too long for the new format.

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/Moddoc.h
    trunk/OpenMPT/mptrack/Modedit.cpp

Modified: trunk/OpenMPT/mptrack/Moddoc.h
===================================================================
--- trunk/OpenMPT/mptrack/Moddoc.h	2009-09-09 22:43:27 UTC (rev 357)
+++ trunk/OpenMPT/mptrack/Moddoc.h	2009-09-09 23:14:18 UTC (rev 358)
@@ -296,6 +296,10 @@
 	virtual void SetModifiedFlag(BOOL bModified=TRUE);
 	//}}AFX_VIRTUAL
 
+	// for mod conversion
+	bool UpdateEnvelopes(INSTRUMENTENVELOPE *mptEnv);
+
+
 // Implementation
 public:
 	virtual ~CModDoc();

Modified: trunk/OpenMPT/mptrack/Modedit.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Modedit.cpp	2009-09-09 22:43:27 UTC (rev 357)
+++ trunk/OpenMPT/mptrack/Modedit.cpp	2009-09-09 23:14:18 UTC (rev 358)
@@ -654,7 +654,7 @@
 	// Convert MOD/XM to S3M/IT/MPT
 	if (oldTypeIsMOD_XM && newTypeIsS3M_IT_MPT)
 	{
-		for (UINT i=1; i<=m_SndFile.m_nSamples; i++)
+		for (SAMPLEINDEX i=1; i<=m_SndFile.m_nSamples; i++)
 		{
 			m_SndFile.Samples[i].nC5Speed = CSoundFile::TransposeToFrequency(m_SndFile.Samples[i].RelativeTone, m_SndFile.Samples[i].nFineTune);
 			m_SndFile.Samples[i].RelativeTone = 0;
@@ -666,13 +666,13 @@
 	// Convert S3M/IT/MPT to XM
 	if (oldTypeIsS3M_IT_MPT && newTypeIsXM)
 	{
-		for (UINT i=1; i<=m_SndFile.m_nSamples; i++)
+		for (SAMPLEINDEX i=1; i<=m_SndFile.m_nSamples; i++)
 		{
 			CSoundFile::FrequencyToTranspose(&m_SndFile.Samples[i]);
 			if (!(m_SndFile.Samples[i].uFlags & CHN_PANNING)) m_SndFile.Samples[i].nPan = 128;
 		}
 		bool bBrokenNoteMap = false, bBrokenSustainLoop = false;
-		for (UINT j = 1; j <= m_SndFile.m_nInstruments; j++)
+		for (INSTRUMENTINDEX j = 1; j <= m_SndFile.m_nInstruments; j++)
 		{
 			MODINSTRUMENT *pIns = m_SndFile.Instruments[j];
 			if (pIns)
@@ -747,6 +747,16 @@
 	m_SndFile.m_nDefaultTempo = CLAMP(m_SndFile.m_nDefaultTempo, specs.tempoMin, specs.tempoMax);
 	m_SndFile.m_nDefaultSpeed = CLAMP(m_SndFile.m_nDefaultSpeed, specs.speedMin, specs.speedMax);
 
+	bool bTrimmedEnvelopes = false;
+	for(INSTRUMENTINDEX i = 1; i <= m_SndFile.m_nInstruments; i++)
+	{
+		bTrimmedEnvelopes |= UpdateEnvelopes(&m_SndFile.Instruments[i]->VolEnv);
+		bTrimmedEnvelopes |= UpdateEnvelopes(&m_SndFile.Instruments[i]->PanEnv);
+		bTrimmedEnvelopes |= UpdateEnvelopes(&m_SndFile.Instruments[i]->PitchEnv);
+	}
+	if(bTrimmedEnvelopes == true)
+		AddToLog("WARNING: Instrument envelopes have been shortened.\n");
+
 	SetModified();
 	ClearUndo();
 	UpdateAllViews(NULL, HINT_MODTYPE | HINT_MODGENERAL);
@@ -754,11 +764,32 @@
 	return TRUE;
 }
 
+bool CModDoc::UpdateEnvelopes(INSTRUMENTENVELOPE *mptEnv)
+//-------------------------------------------------------
+{
+	// shorten instrument envelope if necessary (for mod conversion)
+	const int iEnvMax = m_SndFile.GetModSpecifications().envelopePointsMax;
+	bool bResult = false;
 
+	#define TRIMENV(i) if(i > iEnvMax) {i = iEnvMax; bResult = true;}
 
+	TRIMENV(mptEnv->nNodes);
+	TRIMENV(mptEnv->nLoopStart);
+	TRIMENV(mptEnv->nLoopEnd);
+	TRIMENV(mptEnv->nSustainStart);
+	TRIMENV(mptEnv->nSustainEnd);
+	TRIMENV(mptEnv->nReleaseNode);
 
+	#undef TRIMENV
 
+	return bResult;
+}
 
+
+
+
+
+
 // Change the number of channels
 BOOL CModDoc::ChangeNumChannels(UINT nNewChannels, const bool showCancelInRemoveDlg)
 //------------------------------------------------


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-09-09 22:43:42

Revision: 357
          http://modplug.svn.sourceforge.net/modplug/?rev=357&view=rev
Author:   saga-games
Date:     2009-09-09 22:43:27 +0000 (Wed, 09 Sep 2009)

Log Message:
-----------
[New] MPTM: Allow up to 240 envelope points (did not set it to 255 to have a safety margin). Write additional loop points to extended instrument properties.
[Ref] Rewrote a bit of the IT loader to avoid C&P code, removed constants where they should not be used

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/View_ins.cpp
    trunk/OpenMPT/soundlib/Load_it.cpp
    trunk/OpenMPT/soundlib/Load_xm.cpp
    trunk/OpenMPT/soundlib/Snd_defs.h
    trunk/OpenMPT/soundlib/mod_specifications.h

Modified: trunk/OpenMPT/mptrack/View_ins.cpp
===================================================================
--- trunk/OpenMPT/mptrack/View_ins.cpp	2009-09-07 20:24:18 UTC (rev 356)
+++ trunk/OpenMPT/mptrack/View_ins.cpp	2009-09-09 22:43:27 UTC (rev 357)
@@ -1256,9 +1256,6 @@
 			int nValue = ScreenToValue(m_ptMenu.y);
 			if(nTick < 0) return false;
 
-			UINT maxpoints = (pSndFile->m_nType == MOD_TYPE_XM) ? 12 : 25;
-			//To check: Should there be MAX_ENVPOINTS?
-
 			nValue = CLAMP(nValue, 0, 64);
 
 			INSTRUMENTENVELOPE *envelope = GetEnvelopePtr();
@@ -1280,7 +1277,7 @@
 				return false;
 			}
 
-			if (envelope->nNodes < maxpoints)
+			if (envelope->nNodes < pSndFile->GetModSpecifications().envelopePointsMax)
 			{
 				if (!envelope->nNodes)
 				{
@@ -1973,8 +1970,6 @@
 	CModDoc *pModDoc = GetDocument();
 	if ((pModDoc) && (node>0) && (node <= EnvGetLastPoint()))
 	{
-		CSoundFile *pSndFile = pModDoc->GetSoundFile();
-
 		INSTRUMENTENVELOPE *envelope = GetEnvelopePtr();
 		if(envelope == nullptr) return;
 

Modified: trunk/OpenMPT/soundlib/Load_it.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_it.cpp	2009-09-07 20:24:18 UTC (rev 356)
+++ trunk/OpenMPT/soundlib/Load_it.cpp	2009-09-09 22:43:27 UTC (rev 357)
@@ -216,11 +216,31 @@
 	return (value > 9)  ? 9 : value;
 }
 
+// Convert IT/MPTM envelope data into MPT's internal envelope format - To be used by ITInstrToMPT()
+void ITEnvToMPT(const ITENVELOPE *itEnv, INSTRUMENTENVELOPE *mptEnv, const BYTE envOffset, const int iEnvMax)
+//-----------------------------------------------------------------------------------------------------------
+{
+	mptEnv->nNodes = min(itEnv->num, iEnvMax);
+	mptEnv->nLoopStart = itEnv->lpb;
+	mptEnv->nLoopEnd = itEnv->lpe;
+	mptEnv->nSustainStart = itEnv->slb;
+	mptEnv->nSustainEnd = itEnv->sle;
 
+	// Attention: Full MPTM envelope is stored in extended instrument properties
+	for (UINT ev = 0; ev < 25; ev++)
+	{
+		mptEnv->Values[ev] = itEnv->data[ev * 3] + envOffset;
+		mptEnv->Ticks[ev] = (itEnv->data[ev * 3 + 2] << 8) | (itEnv->data[ev * 3 + 1]);
+	}
+}
+
 //BOOL CSoundFile::ITInstrToMPT(const void *p, MODINSTRUMENT *pIns, UINT trkvers)
 long CSoundFile::ITInstrToMPT(const void *p, MODINSTRUMENT *pIns, UINT trkvers) //rewbs.modularInstData
 //--------------------------------------------------------------------------------
 {	
+	// Envelope point count. Limited to 25 in IT format.
+	const int iEnvMax = (m_nType & MOD_TYPE_MPT) ? MAX_ENVPOINTS : 25;
+
 	long returnVal=0;
 	pIns->pTuning = m_defaultInstrument.pTuning;
 	pIns->nPluginVelocityHandling = PLUGIN_VELOCITYHANDLING_CHANNEL;
@@ -257,6 +277,7 @@
 			}
 			pIns->VolEnv.Values[ev] = pis->nodes[ev*2+1];
 		}
+
 		pIns->nNNA = pis->nna;
 		pIns->nDCT = pis->dnc;
 		pIns->nPan = 0x80;
@@ -283,7 +304,7 @@
 		pIns->nFadeOut = pis->fadeout << 5; // should be 6?
 		pIns->nGlobalVol = pis->gbv >> 1;
 		if (pIns->nGlobalVol > 64) pIns->nGlobalVol = 64;
-		for (UINT j=0; j<NOTE_MAX; j++)
+		for (UINT j = 0; j < 120; j++)
 		{
 			UINT note = pis->keyboard[j*2];
 			UINT ins = pis->keyboard[j*2+1];
@@ -295,7 +316,7 @@
 		if (*((int *)pis->dummy) == 'MPTX')
 		{
 			const ITINSTRUMENTEX *pisex = (const ITINSTRUMENTEX *)pis;
-			for (UINT k=0; k<NOTE_MAX; k++)
+			for (UINT k = 0; k < 120; k++)
 			{
 				pIns->Keyboard[k] |= ((UINT)pisex->keyboardhi[k] << 8);
 			}
@@ -352,45 +373,21 @@
 		if (pis->volenv.flags & 2) pIns->dwFlags |= ENV_VOLLOOP;
 		if (pis->volenv.flags & 4) pIns->dwFlags |= ENV_VOLSUSTAIN;
 		if (pis->volenv.flags & 8) pIns->dwFlags |= ENV_VOLCARRY;
-		pIns->VolEnv.nNodes = pis->volenv.num;
-		if (pIns->VolEnv.nNodes > 25) pIns->VolEnv.nNodes = 25;
-		pIns->VolEnv.nLoopStart = pis->volenv.lpb;
-		pIns->VolEnv.nLoopEnd = pis->volenv.lpe;
-		pIns->VolEnv.nSustainStart = pis->volenv.slb;
-		pIns->VolEnv.nSustainEnd = pis->volenv.sle;
+		ITEnvToMPT(&pis->volenv, &pIns->VolEnv, 0, iEnvMax);
 		// Panning Envelope 
 		if (pis->panenv.flags & 1) pIns->dwFlags |= ENV_PANNING;
 		if (pis->panenv.flags & 2) pIns->dwFlags |= ENV_PANLOOP;
 		if (pis->panenv.flags & 4) pIns->dwFlags |= ENV_PANSUSTAIN;
 		if (pis->panenv.flags & 8) pIns->dwFlags |= ENV_PANCARRY;
-		pIns->PanEnv.nNodes = pis->panenv.num;
-		if (pIns->PanEnv.nNodes > 25) pIns->PanEnv.nNodes = 25;
-		pIns->PanEnv.nLoopStart = pis->panenv.lpb;
-		pIns->PanEnv.nLoopEnd = pis->panenv.lpe;
-		pIns->PanEnv.nSustainStart = pis->panenv.slb;
-		pIns->PanEnv.nSustainEnd = pis->panenv.sle;
+		ITEnvToMPT(&pis->panenv, &pIns->PanEnv, 32, iEnvMax);
 		// Pitch Envelope 
 		if (pis->pitchenv.flags & 1) pIns->dwFlags |= ENV_PITCH;
 		if (pis->pitchenv.flags & 2) pIns->dwFlags |= ENV_PITCHLOOP;
 		if (pis->pitchenv.flags & 4) pIns->dwFlags |= ENV_PITCHSUSTAIN;
 		if (pis->pitchenv.flags & 8) pIns->dwFlags |= ENV_PITCHCARRY;
 		if (pis->pitchenv.flags & 0x80) pIns->dwFlags |= ENV_FILTER;
-		pIns->PitchEnv.nNodes = pis->pitchenv.num;
-		if (pIns->PitchEnv.nNodes > 25) pIns->PitchEnv.nNodes = 25;
-		pIns->PitchEnv.nLoopStart = pis->pitchenv.lpb;
-		pIns->PitchEnv.nLoopEnd = pis->pitchenv.lpe;
-		pIns->PitchEnv.nSustainStart = pis->pitchenv.slb;
-		pIns->PitchEnv.nSustainEnd = pis->pitchenv.sle;
-		// Envelopes Data
-		for (UINT ev=0; ev<25; ev++)
-		{
-			pIns->VolEnv.Values[ev] = pis->volenv.data[ev*3];
-			pIns->VolEnv.Ticks[ev] = (pis->volenv.data[ev*3+2] << 8) | (pis->volenv.data[ev*3+1]);
-			pIns->PanEnv.Values[ev] = pis->panenv.data[ev*3] + 32;
-			pIns->PanEnv.Ticks[ev] = (pis->panenv.data[ev*3+2] << 8) | (pis->panenv.data[ev*3+1]);
-			pIns->PitchEnv.Values[ev] = pis->pitchenv.data[ev*3] + 32;
-			pIns->PitchEnv.Ticks[ev] = (pis->pitchenv.data[ev*3+2] << 8) | (pis->pitchenv.data[ev*3+1]);
-		}
+		ITEnvToMPT(&pis->pitchenv, &pIns->PitchEnv, 32, iEnvMax);
+
 		pIns->nNNA = pis->nna;
 		pIns->nDCT = pis->dct;
 		pIns->nDNA = pis->dca;
@@ -407,9 +404,10 @@
 		if (pIns->nPan > 256) pIns->nPan = 128;
 		if (pis->dfp < 0x80) pIns->dwFlags |= ENV_SETPANNING;
 	}
-	if ((pIns->VolEnv.nLoopStart >= 25) || (pIns->VolEnv.nLoopEnd >= 25)) pIns->dwFlags &= ~ENV_VOLLOOP;
-	if ((pIns->VolEnv.nSustainStart >= 25) || (pIns->VolEnv.nSustainEnd >= 25)) pIns->dwFlags &= ~ENV_VOLSUSTAIN;
 
+	if ((pIns->VolEnv.nLoopStart >= iEnvMax) || (pIns->VolEnv.nLoopEnd >= iEnvMax)) pIns->dwFlags &= ~ENV_VOLLOOP;
+	if ((pIns->VolEnv.nSustainStart >= iEnvMax) || (pIns->VolEnv.nSustainEnd >= iEnvMax)) pIns->dwFlags &= ~ENV_VOLSUSTAIN;
+
 	return returnVal; //return offset
 }
 
@@ -3504,7 +3502,20 @@
 	WriteInstrumentPropertyForAllInstruments('PTTL', sizeof(m_defaultInstrument.wPitchToTempoLock),  f, instruments, nInstruments);
 	WriteInstrumentPropertyForAllInstruments('PVEH', sizeof(m_defaultInstrument.nPluginVelocityHandling),  f, instruments, nInstruments);
 	WriteInstrumentPropertyForAllInstruments('PVOH', sizeof(m_defaultInstrument.nPluginVolumeHandling),  f, instruments, nInstruments);
-		
+
+	if(m_nType & MOD_TYPE_MPT)
+	{
+		// write full envelope information for MPTM files (more env points)
+		WriteInstrumentPropertyForAllInstruments('VP[.', sizeof(m_defaultInstrument.VolEnv.Ticks ), f, instruments, nInstruments);
+		WriteInstrumentPropertyForAllInstruments('VE[.', sizeof(m_defaultInstrument.VolEnv.Values), f, instruments, nInstruments);
+
+		WriteInstrumentPropertyForAllInstruments('PP[.', sizeof(m_defaultInstrument.PanEnv.Ticks), f, instruments, nInstruments);
+		WriteInstrumentPropertyForAllInstruments('PE[.', sizeof(m_defaultInstrument.PanEnv.Values),  f, instruments, nInstruments);
+
+		WriteInstrumentPropertyForAllInstruments('PiP[', sizeof(m_defaultInstrument.PitchEnv.Ticks),  f, instruments, nInstruments);
+		WriteInstrumentPropertyForAllInstruments('PiE[', sizeof(m_defaultInstrument.PitchEnv.Values),  f, instruments, nInstruments);
+	}
+
 	return;
 }
 

Modified: trunk/OpenMPT/soundlib/Load_xm.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_xm.cpp	2009-09-07 20:24:18 UTC (rev 356)
+++ trunk/OpenMPT/soundlib/Load_xm.cpp	2009-09-09 22:43:27 UTC (rev 357)
@@ -51,7 +51,7 @@
 	DWORD shsize; // size of XMSAMPLESTRUCT
 	BYTE snum[96];
 	WORD venv[24];
-	WORD pIns[24];
+	WORD penv[24];
 	BYTE vnum, pnum;
 	BYTE vsustain, vloops, vloope, psustain, ploops, ploope;
 	BYTE vtype, ptype;
@@ -354,7 +354,7 @@
 
 			for (int i = 0; i < 24; ++i) {
 				xmsh.venv[i] = LittleEndianW(xmsh.venv[i]);
-				xmsh.pIns[i] = LittleEndianW(xmsh.pIns[i]);
+				xmsh.penv[i] = LittleEndianW(xmsh.penv[i]);
 			}
 			xmsh.volfade = LittleEndianW(xmsh.volfade);
 			xmsh.res = LittleEndianW(xmsh.res);
@@ -473,8 +473,8 @@
 		{
 			pIns->VolEnv.Ticks[ienv] = (WORD)xmsh.venv[ienv*2];
 			pIns->VolEnv.Values[ienv] = (BYTE)xmsh.venv[ienv*2+1];
-			pIns->PanEnv.Ticks[ienv] = (WORD)xmsh.pIns[ienv*2];
-			pIns->PanEnv.Values[ienv] = (BYTE)xmsh.pIns[ienv*2+1];
+			pIns->PanEnv.Ticks[ienv] = (WORD)xmsh.penv[ienv*2];
+			pIns->PanEnv.Values[ienv] = (BYTE)xmsh.penv[ienv*2+1];
 			if (ienv)
 			{
 				if (pIns->VolEnv.Ticks[ienv] < pIns->VolEnv.Ticks[ienv-1])
@@ -871,8 +871,8 @@
 				{
 					xmsh.venv[ienv*2] = pIns->VolEnv.Ticks[ienv];
 					xmsh.venv[ienv*2+1] = pIns->VolEnv.Values[ienv];
-					xmsh.pIns[ienv*2] = pIns->PanEnv.Ticks[ienv];
-					xmsh.pIns[ienv*2+1] = pIns->PanEnv.Values[ienv];
+					xmsh.penv[ienv*2] = pIns->PanEnv.Ticks[ienv];
+					xmsh.penv[ienv*2+1] = pIns->PanEnv.Values[ienv];
 				}
 				if (pIns->dwFlags & ENV_VOLUME) xmsh.vtype |= 1;
 				if (pIns->dwFlags & ENV_VOLSUSTAIN) xmsh.vtype |= 2;

Modified: trunk/OpenMPT/soundlib/Snd_defs.h
===================================================================
--- trunk/OpenMPT/soundlib/Snd_defs.h	2009-09-07 20:24:18 UTC (rev 356)
+++ trunk/OpenMPT/soundlib/Snd_defs.h	2009-09-09 22:43:27 UTC (rev 357)
@@ -71,7 +71,7 @@
 #define MAX_BASECHANNELS	127	// Max pattern channels.
 //#endif
 // -! BEHAVIOUR_CHANGE#0006
-#define MAX_ENVPOINTS		32
+#define MAX_ENVPOINTS		240
 #define MIN_PERIOD			0x0020
 #define MAX_PERIOD			0xFFFF
 #define MAX_PATTERNNAME		32

Modified: trunk/OpenMPT/soundlib/mod_specifications.h
===================================================================
--- trunk/OpenMPT/soundlib/mod_specifications.h	2009-09-07 20:24:18 UTC (rev 356)
+++ trunk/OpenMPT/soundlib/mod_specifications.h	2009-09-09 22:43:27 UTC (rev 357)
@@ -36,6 +36,7 @@
 	UINT speedMin;
 	UINT speedMax;
 	bool hasComments;
+	int envelopePointsMax;
 };
 
 
@@ -71,6 +72,7 @@
 	1,									//Min Speed
 	255,								//Max Speed
 	true,								//Has song comments
+	240,								//Envelope point count
 };
 
 
@@ -101,6 +103,7 @@
 	1,									//Min Speed
 	31,									//Max Speed
 	false,								//No song comments
+	0,									//Envelope point count
 };
 
 // MOD with MPT extensions.
@@ -129,6 +132,7 @@
 	1,									//Min Speed
 	31,									//Max Speed
 	false,								//No song comments
+	0,									//Envelope point count
 };
 
 const CModSpecifications xm =
@@ -156,6 +160,7 @@
 	1,									//Min Speed
 	31,									//Max Speed
 	false,								//No song comments
+	12,									//Envelope point count
 };
 
 // XM with MPT extensions
@@ -184,6 +189,7 @@
 	1,									//Min Speed
 	31,									//Max Speed
 	true,								//Has song comments
+	12,									//Envelope point count
 };
 
 const CModSpecifications s3m =
@@ -210,6 +216,7 @@
 	1,									//Min Speed
 	255,								//Max Speed
 	false,								//No song comments
+	0,									//Envelope point count
 };
 
 // S3M with MPT extensions
@@ -238,6 +245,7 @@
 	1,									//Min Speed
 	255,								//Max Speed
 	false,								//No song comments
+	0,									//Envelope point count
 };
 
 const CModSpecifications it =
@@ -265,6 +273,7 @@
 	1,									//Min Speed
 	255,								//Max Speed
 	true,								//Has song comments
+	25,									//Envelope point count
 };
 
 const CModSpecifications itEx =
@@ -292,6 +301,7 @@
 	1,									//Min Speed
 	255,								//Max Speed
 	true,								//Has song comments
+	25,									//Envelope point count
 };
 
 } //namespace ModSpecs


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-09-07 20:24:27

Revision: 356
          http://modplug.svn.sourceforge.net/modplug/?rev=356&view=rev
Author:   saga-games
Date:     2009-09-07 20:24:18 +0000 (Mon, 07 Sep 2009)

Log Message:
-----------
[New] Pattern editor: When shift-clicking somewhere, a selection will be drawn from the previous cursor position to the new position.
[Fix] Mod Saving: The compatibility export was only working properly for 8-bit mono samples. Everything else is going to be downsampled later, so the sample "fixing" has to be done before.

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/View_pat.cpp
    trunk/OpenMPT/soundlib/Load_mod.cpp

Modified: trunk/OpenMPT/mptrack/View_pat.cpp
===================================================================
--- trunk/OpenMPT/mptrack/View_pat.cpp	2009-09-06 19:53:01 UTC (rev 355)
+++ trunk/OpenMPT/mptrack/View_pat.cpp	2009-09-07 20:24:18 UTC (rev 356)
@@ -1032,32 +1032,40 @@
 			DragToSel(m_dwEndSel, TRUE);
 		} else */
 		{
-			m_dwStartSel = GetPositionFromPoint(point);
-			if (((m_dwStartSel & 0xFFFF) >> 3) < pModDoc->GetNumChannels())
+			if(CMainFrame::GetInputHandler()->ShiftPressed())
 			{
-				m_dwStatus |= PATSTATUS_MOUSEDRAGSEL;
+				// Shift pressed -> set 2nd selection point
+				DragToSel(GetPositionFromPoint(point), TRUE);
+			} else
+			{
+				// Set first selection point
+				m_dwStartSel = GetPositionFromPoint(point);
+				if (((m_dwStartSel & 0xFFFF) >> 3) < pModDoc->GetNumChannels())
+				{
+					m_dwStatus |= PATSTATUS_MOUSEDRAGSEL;
 
-				if (m_dwStatus & PATSTATUS_CTRLDRAGSEL)
-				{
-					SetCurSel(m_dwStartSel, m_dwStartSel);
+					if (m_dwStatus & PATSTATUS_CTRLDRAGSEL)
+					{
+						SetCurSel(m_dwStartSel, m_dwStartSel);
+					}
+					if ((CMainFrame::m_dwPatternSetup & PATTERN_DRAGNDROPEDIT)
+					&& ((m_dwBeginSel != m_dwEndSel) || (m_dwStatus & PATSTATUS_CTRLDRAGSEL))
+					&& ((m_dwStartSel >> 16) >= (m_dwBeginSel >> 16))
+					&& ((m_dwStartSel >> 16) <= (m_dwEndSel >> 16))
+					&& ((m_dwStartSel & 0xFFFF) >= (m_dwBeginSel & 0xFFFF))
+					&& ((m_dwStartSel & 0xFFFF) <= (m_dwEndSel & 0xFFFF)))
+					{
+						m_dwStatus |= PATSTATUS_DRAGNDROPEDIT;
+					} else
+					if (CMainFrame::m_dwPatternSetup & PATTERN_CENTERROW)
+					{
+						SetCurSel(m_dwStartSel, m_dwStartSel);
+					} else
+					{
+						// Fix: Horizontal scrollbar pos screwed when selecting with mouse
+						SetCursorPosition( m_dwStartSel >> 16, m_dwStartSel & 0xFFFF );
+					}
 				}
-				if ((CMainFrame::m_dwPatternSetup & PATTERN_DRAGNDROPEDIT)
-				&& ((m_dwBeginSel != m_dwEndSel) || (m_dwStatus & PATSTATUS_CTRLDRAGSEL))
-				&& ((m_dwStartSel >> 16) >= (m_dwBeginSel >> 16))
-				&& ((m_dwStartSel >> 16) <= (m_dwEndSel >> 16))
-				&& ((m_dwStartSel & 0xFFFF) >= (m_dwBeginSel & 0xFFFF))
-				&& ((m_dwStartSel & 0xFFFF) <= (m_dwEndSel & 0xFFFF)))
-				{
-					m_dwStatus |= PATSTATUS_DRAGNDROPEDIT;
-				} else
-				if (CMainFrame::m_dwPatternSetup & PATTERN_CENTERROW)
-				{
-					SetCurSel(m_dwStartSel, m_dwStartSel);
-				} else
-				{
-					// Fix: Horizontal scrollbar pos screwed when selecting with mouse
-					SetCursorPosition( m_dwStartSel >> 16, m_dwStartSel & 0xFFFF );
-				}
 			}
 		}
 	}

Modified: trunk/OpenMPT/soundlib/Load_mod.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_mod.cpp	2009-09-06 19:53:01 UTC (rev 355)
+++ trunk/OpenMPT/soundlib/Load_mod.cpp	2009-09-07 20:24:18 UTC (rev 356)
@@ -546,8 +546,8 @@
 		MODSAMPLE *pSmp = &Samples[insmap[ismpd]];
 		if(bCompatibilityExport == true) // first two bytes have to be 0 due to PT's one-shot loop ("no loop")
 		{
-			if(pSmp->nLength > 0) pSmp->pSample[0] = 0;
-			if(pSmp->nLength > 1) pSmp->pSample[1] = 0;
+			int iOverwriteLen = 2 * pSmp->GetElementarySampleSize() * ((pSmp->uFlags & CHN_STEREO) ? 2 : 1);
+			memset(pSmp->pSample, 0, min(iOverwriteLen, pSmp->GetSampleSizeInBytes()));
 		}
 		UINT flags = RS_PCM8S;
 #ifndef NO_PACKING


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-09-06 19:53:11

Revision: 355
          http://modplug.svn.sourceforge.net/modplug/?rev=355&view=rev
Author:   saga-games
Date:     2009-09-06 19:53:01 +0000 (Sun, 06 Sep 2009)

Log Message:
-----------
[Fix] Pattern editor: Find/Replace works now, also with high instrument numbers. Also, empty instrument numbers won't be affected by "ins+1" anymore 
[Imp] Pattern editor: Find/Replace has "Search in whole song" and "Replace all" enabled by default.

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/View_ins.cpp
    trunk/OpenMPT/mptrack/View_pat.cpp
    trunk/OpenMPT/mptrack/View_pat.h
    trunk/OpenMPT/mptrack/dlg_misc.cpp

Modified: trunk/OpenMPT/mptrack/View_ins.cpp
===================================================================
--- trunk/OpenMPT/mptrack/View_ins.cpp	2009-09-06 16:09:09 UTC (rev 354)
+++ trunk/OpenMPT/mptrack/View_ins.cpp	2009-09-06 19:53:01 UTC (rev 355)
@@ -1974,7 +1974,6 @@
 	if ((pModDoc) && (node>0) && (node <= EnvGetLastPoint()))
 	{
 		CSoundFile *pSndFile = pModDoc->GetSoundFile();
-		MODINSTRUMENT *pIns = pSndFile->Instruments[m_nInstrument];
 
 		INSTRUMENTENVELOPE *envelope = GetEnvelopePtr();
 		if(envelope == nullptr) return;

Modified: trunk/OpenMPT/mptrack/View_pat.cpp
===================================================================
--- trunk/OpenMPT/mptrack/View_pat.cpp	2009-09-06 16:09:09 UTC (rev 354)
+++ trunk/OpenMPT/mptrack/View_pat.cpp	2009-09-06 19:53:01 UTC (rev 355)
@@ -25,8 +25,8 @@
 MODCOMMAND CViewPattern::m_cmdOld = {0,0,0,0,0,0};
 MODCOMMAND CViewPattern::m_cmdFind = {0,0,0,0,0,0};
 MODCOMMAND CViewPattern::m_cmdReplace = {0,0,0,0,0,0};
-DWORD CViewPattern::m_dwFindFlags = 0;
-DWORD CViewPattern::m_dwReplaceFlags = 0;
+DWORD CViewPattern::m_dwFindFlags = PATSEARCH_FULLSEARCH;
+DWORD CViewPattern::m_dwReplaceFlags = PATSEARCH_REPLACEALL;
 UINT CViewPattern::m_nFindMinChn = 0;
 UINT CViewPattern::m_nFindMaxChn = 0;
 signed char cInstrRelChange = 0;
@@ -1901,11 +1901,11 @@
 					if ((m_dwReplaceFlags & PATSEARCH_INSTR))
 					{
 						// Instr--
-						if (m_cInstrRelChange == -1)
-							if (m->instr > 1) m->instr--;
+						if (m_cInstrRelChange == -1 && m->instr > 1)
+							m->instr--;
 						// Instr++
-						else if (m_cInstrRelChange == 1)
-							if (m->instr < MAX_INSTRUMENTS - 1) m->instr++;
+						else if (m_cInstrRelChange == 1 && m->instr > 0 && m->instr < (MAX_INSTRUMENTS - 1))
+							m->instr++;
 						else m->instr = m_cmdReplace.instr;
 					}
 					if ((m_dwReplaceFlags & PATSEARCH_VOLCMD))

Modified: trunk/OpenMPT/mptrack/View_pat.h
===================================================================
--- trunk/OpenMPT/mptrack/View_pat.h	2009-09-06 16:09:09 UTC (rev 354)
+++ trunk/OpenMPT/mptrack/View_pat.h	2009-09-06 19:53:01 UTC (rev 355)
@@ -76,7 +76,7 @@
 	static MODCOMMAND m_cmdFind, m_cmdReplace, m_cmdOld;
 	static DWORD m_dwFindFlags, m_dwReplaceFlags;
 	static UINT m_nFindMinChn, m_nFindMaxChn;
-	signed char m_cInstrRelChange; // relative instrument change (quick'n'dirty fix)
+	signed char m_cInstrRelChange; // relative instrument change (quick'n'dirty fix, this should be implemented in a less cryptic way)
 
 protected:
 	CFastBitmap m_Dib;

Modified: trunk/OpenMPT/mptrack/dlg_misc.cpp
===================================================================
--- trunk/OpenMPT/mptrack/dlg_misc.cpp	2009-09-06 16:09:09 UTC (rev 354)
+++ trunk/OpenMPT/mptrack/dlg_misc.cpp	2009-09-06 19:53:01 UTC (rev 355)
@@ -847,6 +847,8 @@
 	// Instrument
 	if ((combo = (CComboBox *)GetDlgItem(IDC_COMBO2)) != NULL)
 	{
+		m_nInstr = 0;
+		cInstrRelChange = 0;
 		switch(combo->GetItemData(combo->GetCurSel()))
 		{
 		case replaceInstrumentMinusOne:
@@ -857,7 +859,6 @@
 			break;
 		default:
 			m_nInstr = combo->GetItemData(combo->GetCurSel());
-			cInstrRelChange = 0;
 			break;
 		}
 	}


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-09-06 16:09:20

Revision: 354
          http://modplug.svn.sourceforge.net/modplug/?rev=354&view=rev
Author:   saga-games
Date:     2009-09-06 16:09:09 +0000 (Sun, 06 Sep 2009)

Log Message:
-----------
[Fix] Rearrange Samples: Sample names were copied to the mod title (again...)
[Fix] Treeview: Playing sounds from a soundfont was broken

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/MainFrm.cpp
    trunk/OpenMPT/mptrack/Moddoc.cpp
    trunk/OpenMPT/mptrack/Moddoc.h
    trunk/OpenMPT/mptrack/Modedit.cpp

Modified: trunk/OpenMPT/mptrack/MainFrm.cpp
===================================================================
--- trunk/OpenMPT/mptrack/MainFrm.cpp	2009-09-06 12:45:07 UTC (rev 353)
+++ trunk/OpenMPT/mptrack/MainFrm.cpp	2009-09-06 16:09:09 UTC (rev 354)
@@ -2008,6 +2008,7 @@
 	m_WaveFile.m_nChannels = 4;
 	m_WaveFile.m_nInstruments = 1;
 	m_WaveFile.m_nSamples = 1;
+	m_WaveFile.Order.resize(3);
 	m_WaveFile.Order[0] = 0;
 	m_WaveFile.Order[1] = 1;
 	m_WaveFile.Order[2] = m_WaveFile.Order.GetInvalidPatIndex();

Modified: trunk/OpenMPT/mptrack/Moddoc.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Moddoc.cpp	2009-09-06 12:45:07 UTC (rev 353)
+++ trunk/OpenMPT/mptrack/Moddoc.cpp	2009-09-06 16:09:09 UTC (rev 354)
@@ -62,7 +62,7 @@
 	ON_COMMAND(ID_INSTRUMENTS_REMOVEALL,OnRemoveAllInstruments)
 // -> CODE#0020
 // -> DESC="rearrange sample list"
-	ON_COMMAND(ID_REARRANGE_SAMPLES,	RearrangeSampleList)
+	ON_COMMAND(ID_REARRANGE_SAMPLES,	RearrangeSamples)
 // -! NEW_FEATURE#0020
 	ON_COMMAND(ID_ESTIMATESONGLENGTH,	OnEstimateSongLength)
 	ON_COMMAND(ID_APPROX_BPM,			OnApproximateBPM)
@@ -1641,7 +1641,7 @@
 			::MessageBox(NULL,"Warning: the exported file will not contain any of MPT's file-format hacks.", "Compatibility export warning.",MB_ICONINFORMATION | MB_OK);
 			break;
 		default:
-			::MessageBox(NULL,"Compatibility export is currently only available for MOD and IT modules.", "Can't do compatibility export.",MB_ICONINFORMATION | MB_OK);
+			::MessageBox(NULL,"Compatibility export is currently only available for MOD, XM and IT modules.", "Can't do compatibility export.",MB_ICONINFORMATION | MB_OK);
 			return;
 	}
 

Modified: trunk/OpenMPT/mptrack/Moddoc.h
===================================================================
--- trunk/OpenMPT/mptrack/Moddoc.h	2009-09-06 12:45:07 UTC (rev 353)
+++ trunk/OpenMPT/mptrack/Moddoc.h	2009-09-06 16:09:09 UTC (rev 354)
@@ -194,7 +194,7 @@
 	BOOL RemoveUnusedPlugs();
 	UINT RemovePlugs(const bool (&keepMask)[MAX_MIXPLUGINS]);
 	BOOL RemoveUnusedPatterns(BOOL bRemove=TRUE);
-	void RearrangeSampleList();
+	void RearrangeSamples();
 	BOOL CompoCleanup();
 
 	PATTERNINDEX InsertPattern(ORDERINDEX nOrd = -1, ROWINDEX nRows = 64);

Modified: trunk/OpenMPT/mptrack/Modedit.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Modedit.cpp	2009-09-06 12:45:07 UTC (rev 353)
+++ trunk/OpenMPT/mptrack/Modedit.cpp	2009-09-06 16:09:09 UTC (rev 354)
@@ -1067,8 +1067,8 @@
 
 
 
-void CModDoc::RearrangeSampleList()
-//---------------------------------
+void CModDoc::RearrangeSamples()
+//------------------------------
 {
 	if(m_SndFile.m_nSamples < 2)
 		return;
@@ -1103,7 +1103,7 @@
 			// This gotta be moved
 			m_SndFile.MoveSample(i, nSampleMap[i]);
 			m_SndFile.Samples[i].pSample = nullptr;
-			strcpy(m_SndFile.m_szNames[nSampleMap[i]], m_SndFile.m_szNames[i]);
+			if(nSampleMap[i] > 0) strcpy(m_SndFile.m_szNames[nSampleMap[i]], m_SndFile.m_szNames[i]);
 			memset(m_SndFile.m_szNames[i], 0, sizeof(m_SndFile.m_szNames[i]));
 
 			// Also update instrument mapping (if module is in instrument mode)


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-09-06 12:45:22

Revision: 353
          http://modplug.svn.sourceforge.net/modplug/?rev=353&view=rev
Author:   saga-games
Date:     2009-09-06 12:45:07 +0000 (Sun, 06 Sep 2009)

Log Message:
-----------
[Fix] Playback: Fixed a severe bug that caused a crash when trying to play a module that has an empty order list. (introduced in rev. 338)
[Fix] IT Loader: The fix for old instrument header versions was wrong.
[Fix] Note Properties: When double-clicking on a note in the pattern editor, the noteMin offset was not taken into consideration, which lead to wrong information for some formats.
[Fix] Note Properties: Works partly with PC notes now.
[Imp] Instrument editor: When inserting new envelope points using Shift+Click, the point can now be instantly dragged.
[Imp] Setup: Added note to "always center active row" hint that this is required to be enabled for greyed out patterns
[Imp] XI Saver: Fill out the "created with" field properly (OpenMPT instead of FastTracker 2)
[Ref] Find/Replace: Partly rewrote Ins+/-1 code, does not work yet (didn't work before, either)
[Ref] Renamed Echo Paste to Overflow Paste

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/CommandSet.cpp
    trunk/OpenMPT/mptrack/CommandSet.h
    trunk/OpenMPT/mptrack/Ctrl_ins.cpp
    trunk/OpenMPT/mptrack/Ctrl_pat.cpp
    trunk/OpenMPT/mptrack/Ctrl_pat.h
    trunk/OpenMPT/mptrack/Ctrl_smp.cpp
    trunk/OpenMPT/mptrack/Mainfrm.h
    trunk/OpenMPT/mptrack/Modedit.cpp
    trunk/OpenMPT/mptrack/Moptions.cpp
    trunk/OpenMPT/mptrack/View_ins.cpp
    trunk/OpenMPT/mptrack/View_ins.h
    trunk/OpenMPT/mptrack/View_pat.cpp
    trunk/OpenMPT/mptrack/View_pat.h
    trunk/OpenMPT/mptrack/dlg_misc.cpp
    trunk/OpenMPT/mptrack/dlg_misc.h
    trunk/OpenMPT/mptrack/mptrack.rc
    trunk/OpenMPT/mptrack/res/patterns.bmp
    trunk/OpenMPT/mptrack/resource.h
    trunk/OpenMPT/soundlib/Load_it.cpp
    trunk/OpenMPT/soundlib/Load_psm.cpp
    trunk/OpenMPT/soundlib/Sampleio.cpp
    trunk/OpenMPT/soundlib/Sndmix.cpp

Modified: trunk/OpenMPT/mptrack/CommandSet.cpp
===================================================================
--- trunk/OpenMPT/mptrack/CommandSet.cpp	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/mptrack/CommandSet.cpp	2009-09-06 12:45:07 UTC (rev 353)
@@ -2315,10 +2315,10 @@
 	commands[kcChannelReset].isDummy = false;
 	commands[kcChannelReset].Message = "Reset channel";
 
-	commands[kcSwitchEchoPaste].UID = 1787;
-	commands[kcSwitchEchoPaste].Message = "Switch echo paste";
-	commands[kcSwitchEchoPaste].isHidden = false;
-	commands[kcSwitchEchoPaste].isDummy = false;
+	commands[kcSwitchOverflowPaste].UID = 1787;
+	commands[kcSwitchOverflowPaste].Message = "Toggle overflow paste";
+	commands[kcSwitchOverflowPaste].isHidden = false;
+	commands[kcSwitchOverflowPaste].isDummy = false;
 
 	commands[kcNotePC].UID = 1788;
 	commands[kcNotePC].isHidden = false;

Modified: trunk/OpenMPT/mptrack/CommandSet.h
===================================================================
--- trunk/OpenMPT/mptrack/CommandSet.h	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/mptrack/CommandSet.h	2009-09-06 12:45:07 UTC (rev 353)
@@ -84,7 +84,7 @@
 	kcEditPaste,
 	kcEditMixPaste,
 	kcEditMixPasteITStyle,
-	kcSwitchEchoPaste,
+	kcSwitchOverflowPaste,
 	kcEditSelectAll,
 	kcEditFind,
 	kcEditFindNext,

Modified: trunk/OpenMPT/mptrack/Ctrl_ins.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_ins.cpp	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/mptrack/Ctrl_ins.cpp	2009-09-06 12:45:07 UTC (rev 353)
@@ -314,7 +314,10 @@
 				}
 				wsprintf(s, "Map all notes to sample %d", pIns->Keyboard[m_nNote]);
 				AppendMenu(hMenu, MF_STRING, ID_NOTEMAP_COPY_SMP, s);
-				wsprintf(s, "Map all notes to %s", pSndFile->GetNoteName(pIns->NoteMap[m_nNote], m_nInstrument).c_str());
+				if(pIns->NoteMap[m_nNote] < NOTE_MIN_SPECIAL)
+					wsprintf(s, "Map all notes to %s", pSndFile->GetNoteName(pIns->NoteMap[m_nNote], m_nInstrument).c_str());
+				else
+					wsprintf(s, "Map all notes to %s", szSpecialNoteNames[pIns->NoteMap[m_nNote] - NOTE_MIN_SPECIAL]);
 				AppendMenu(hMenu, MF_STRING, ID_NOTEMAP_COPY_NOTE, s);
 				AppendMenu(hMenu, MF_STRING, ID_NOTEMAP_RESET, "Reset note mapping");
 				AppendMenu(hMenu, MF_STRING, ID_INSTRUMENT_DUPLICATE, "Duplicate Instrument\tShift+New");

Modified: trunk/OpenMPT/mptrack/Ctrl_pat.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_pat.cpp	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/mptrack/Ctrl_pat.cpp	2009-09-06 12:45:07 UTC (rev 353)
@@ -52,7 +52,7 @@
 	ON_COMMAND(ID_PATTERNDETAIL_LO,			OnDetailLo)
 	ON_COMMAND(ID_PATTERNDETAIL_MED,		OnDetailMed)
 	ON_COMMAND(ID_PATTERNDETAIL_HI,			OnDetailHi)
-	ON_COMMAND(ID_ECHOPASTE,				OnToggleEchoPaste)
+	ON_COMMAND(ID_OVERFLOWPASTE,			OnToggleOverflowPaste)
 	ON_CBN_SELCHANGE(IDC_COMBO_INSTRUMENT,	OnInstrumentChanged)
 // -> CODE#0012
 // -> DESC="midi keyboard split"
@@ -158,7 +158,7 @@
 	m_ToolBar.AddButton(ID_PATTERNDETAIL_MED, 31, TBSTYLE_CHECK, TBSTATE_ENABLED);
 	m_ToolBar.AddButton(ID_PATTERNDETAIL_HI, 32, TBSTYLE_CHECK, TBSTATE_ENABLED|TBSTATE_CHECKED);
 	m_ToolBar.AddButton(ID_SEPARATOR, 0, TBSTYLE_SEP);
-	m_ToolBar.AddButton(ID_ECHOPASTE, 38, TBSTYLE_CHECK, ((CMainFrame::m_dwPatternSetup & PATTERN_ECHOPASTE) ? TBSTATE_CHECKED : 0) | TBSTATE_ENABLED);
+	m_ToolBar.AddButton(ID_OVERFLOWPASTE, 38, TBSTYLE_CHECK, ((CMainFrame::m_dwPatternSetup & PATTERN_OVERFLOWPASTE) ? TBSTATE_CHECKED : 0) | TBSTATE_ENABLED);
 
 	// Special edit controls -> tab switch to view
 	m_EditSpacing.SetParent(this);
@@ -297,7 +297,7 @@
 // -> CODE#0007
 // -> DESC="uncheck follow song checkbox by default"
 		CheckDlgButton(IDC_PATTERN_FOLLOWSONG, (CMainFrame::m_dwPatternSetup & PATTERN_FOLLOWSONGOFF) ? MF_UNCHECKED : MF_CHECKED);
-		m_ToolBar.SetState(ID_ECHOPASTE, ((CMainFrame::m_dwPatternSetup & PATTERN_ECHOPASTE) ? TBSTATE_CHECKED : 0) | TBSTATE_ENABLED);
+		m_ToolBar.SetState(ID_OVERFLOWPASTE, ((CMainFrame::m_dwPatternSetup & PATTERN_OVERFLOWPASTE) ? TBSTATE_CHECKED : 0) | TBSTATE_ENABLED);
 // -! BEHAVIOUR_CHANGE#0007
 	}
 	if (dwHintMask & (HINT_MODTYPE|HINT_INSNAMES|HINT_SMPNAMES|HINT_PATNAMES))
@@ -1216,10 +1216,10 @@
 	SwitchToView();
 }
 
-void CCtrlPatterns::OnToggleEchoPaste()
+void CCtrlPatterns::OnToggleOverflowPaste()
 //-------------------------------------
 {
-	CMainFrame::m_dwPatternSetup ^= PATTERN_ECHOPASTE;
+	CMainFrame::m_dwPatternSetup ^= PATTERN_OVERFLOWPASTE;
 	UpdateView(HINT_MPTOPTIONS, NULL);
 	SwitchToView();
 }

Modified: trunk/OpenMPT/mptrack/Ctrl_pat.h
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_pat.h	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/mptrack/Ctrl_pat.h	2009-09-06 12:45:07 UTC (rev 353)
@@ -227,7 +227,7 @@
 	afx_msg void OnUpdateRecord(CCmdUI *pCmdUI);
 	afx_msg void TogglePluginEditor(); //rewbs.instroVST
 	afx_msg void ToggleSplitPluginEditor(); //rewbs.instroVST
-	afx_msg void OnToggleEchoPaste();
+	afx_msg void OnToggleOverflowPaste();
 
 	//}}AFX_MSG
 	DECLARE_MESSAGE_MAP()

Modified: trunk/OpenMPT/mptrack/Ctrl_smp.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_smp.cpp	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/mptrack/Ctrl_smp.cpp	2009-09-06 12:45:07 UTC (rev 353)
@@ -618,7 +618,7 @@
 		DWORD d;
 		
 		// Length / Type
-		wsprintf(s, "%d-bit %s, len: %d", (pSmp->uFlags & CHN_16BIT) ? 16 : 8, (pSmp->uFlags & CHN_STEREO) ? "stereo" : "mono", pSmp->nLength);
+		wsprintf(s, "%d-bit %s, len: %d", pSmp->GetElementarySampleSize() * 8, (pSmp->uFlags & CHN_STEREO) ? "stereo" : "mono", pSmp->nLength);
 		SetDlgItemText(IDC_TEXT5, s);
 		// Name
 		memcpy(s, m_pSndFile->m_szNames[m_nSample], 32);

Modified: trunk/OpenMPT/mptrack/Mainfrm.h
===================================================================
--- trunk/OpenMPT/mptrack/Mainfrm.h	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/mptrack/Mainfrm.h	2009-09-06 12:45:07 UTC (rev 353)
@@ -207,7 +207,7 @@
 #define PATTERN_SYNCMUTE			0x1000000
 #define PATTERN_AUTODELAY			0x2000000 
 #define PATTERN_NOTEFADE			0x4000000
-#define PATTERN_ECHOPASTE			0x8000000
+#define PATTERN_OVERFLOWPASTE		0x8000000
 #define PATTERN_POSITIONAWARETIMER	0x10000000
 #define PATTERN_RESETCHANNELS		0x20000000
 

Modified: trunk/OpenMPT/mptrack/Modedit.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Modedit.cpp	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/mptrack/Modedit.cpp	2009-09-06 12:45:07 UTC (rev 353)
@@ -2315,7 +2315,7 @@
 				nrow++;
 
 				//jojo.echopaste
-				if(CMainFrame::m_dwPatternSetup & PATTERN_ECHOPASTE)
+				if(CMainFrame::m_dwPatternSetup & PATTERN_OVERFLOWPASTE)
 				{
 					while(nrow >= m_SndFile.PatternSize[nPattern])
 					{

Modified: trunk/OpenMPT/mptrack/Moptions.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Moptions.cpp	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/mptrack/Moptions.cpp	2009-09-06 12:45:07 UTC (rev 353)
@@ -605,7 +605,7 @@
 	OPTGEN_SYNCMUTE,
 	OPTGEN_AUTODELAY,
 	OPTGEN_PATNOTEFADE,
-	OPTGEN_ECHOPASTE,
+	OPTGEN_OVERFLOWPASTE,
 	OPTGEN_POSITIONAWARETIMER,
 	OPTGEN_RESETCHANNELS,
 	OPTGEN_MAXOPTIONS
@@ -625,7 +625,7 @@
 	{"Ignored muted channels",			"Notes will not be played on muted channels (unmuting will only start on a new note)."},
 	{"Quick cursor paste Auto-Repeat",	"Leaving the space bar pressed will auto-repeat the action"},
 	{"No loud samples",					"Disable loud playback of samples in the sample/instrument editor"},
-	{"Show Prev/Next patterns",			"Displays grayed-out version of the previous/next patterns in the pattern editor"},
+	{"Show Prev/Next patterns",			"Displays grayed-out version of the previous/next patterns in the pattern editor. Does not work if \"always center active row\" is disabled."},
 	{"Continuous scroll",				"Jumps to the next pattern when moving past the end of a pattern"},
 	{"Record note off",					"Record note off when a key is released on the PC keyboard (Only works in instrument mode)."},
 	{"Follow song off by default",		"Ensure follow song is off when opening or starting a new song."}, 	//rewbs.noFollow
@@ -644,7 +644,7 @@
 	{"Maintain sample sync on mute",	"Samples continue to be processed when channels are muted (like in IT2 and FT2)"},
 	{"Automatic delay commands",	    "Automatically insert appropriate note-delay commands when recording notes during live playback."},
 	{"Note fade on key up",				"Enable to fade/stop notes on key up in pattern tab." },
-	{"Echo paste mode",					"Wrap pasted pattern data into next pattern. This is useful for creating echo channels."},
+	{"Overflow paste mode",				"Wrap pasted pattern data into next pattern. This is useful for creating echo channels."},
 	{"Position aware timer",			"If enabled, timer will show the playback position time if possible instead of running timer."},
 	{"Reset channels on loop",			"If enabled, channels will be reset to their initial state when song looping is enabled.\nNote: This does not affect manual song loops (i.e. triggered by pattern commands)"},
 };
@@ -709,7 +709,7 @@
 
 		case OPTGEN_AUTODELAY:			bCheck = (CMainFrame::m_dwPatternSetup & PATTERN_AUTODELAY); break;
 		case OPTGEN_PATNOTEFADE:		bCheck = (CMainFrame::m_dwPatternSetup & PATTERN_NOTEFADE); break;
-		case OPTGEN_ECHOPASTE:			bCheck = (CMainFrame::m_dwPatternSetup & PATTERN_ECHOPASTE); break;
+		case OPTGEN_OVERFLOWPASTE:		bCheck = (CMainFrame::m_dwPatternSetup & PATTERN_OVERFLOWPASTE); break;
 		case OPTGEN_POSITIONAWARETIMER:	bCheck = (CMainFrame::m_dwPatternSetup & PATTERN_POSITIONAWARETIMER); break;
 		case OPTGEN_RESETCHANNELS:	bCheck = (CMainFrame::m_dwPatternSetup & PATTERN_RESETCHANNELS); break;
 		}
@@ -774,13 +774,13 @@
 //		case OPTGEN_ALTERNTIVEBPMSPEED:	mask = PATTERN_ALTERNTIVEBPMSPEED; break;
 // rewbs: this options is now available under song settings. It is therefore saved with the song.
 // -! NEW_FEATURE#0022		
-		case OPTGEN_PATTERNCTXMENUSTYLE: mask = PATTERN_OLDCTXMENUSTYLE; break;
-		case OPTGEN_SYNCMUTE:			 mask = PATTERN_SYNCMUTE; break;
-		case OPTGEN_AUTODELAY:			 mask = PATTERN_AUTODELAY; break;
-		case OPTGEN_PATNOTEFADE:		 mask = PATTERN_NOTEFADE; break;
-		case OPTGEN_ECHOPASTE:			 mask = PATTERN_ECHOPASTE; break;
-		case OPTGEN_POSITIONAWARETIMER:	 mask = PATTERN_POSITIONAWARETIMER; break;
-		case OPTGEN_RESETCHANNELS:		 mask = PATTERN_RESETCHANNELS; break;
+		case OPTGEN_PATTERNCTXMENUSTYLE:	mask = PATTERN_OLDCTXMENUSTYLE; break;
+		case OPTGEN_SYNCMUTE:				mask = PATTERN_SYNCMUTE; break;
+		case OPTGEN_AUTODELAY:				mask = PATTERN_AUTODELAY; break;
+		case OPTGEN_PATNOTEFADE:			mask = PATTERN_NOTEFADE; break;
+		case OPTGEN_OVERFLOWPASTE:			mask = PATTERN_OVERFLOWPASTE; break;
+		case OPTGEN_POSITIONAWARETIMER:		mask = PATTERN_POSITIONAWARETIMER; break;
+		case OPTGEN_RESETCHANNELS:			mask = PATTERN_RESETCHANNELS; break;
 			
 		} 
 		if (bCheck) CMainFrame::m_dwPatternSetup |= mask; else CMainFrame::m_dwPatternSetup &= ~mask;

Modified: trunk/OpenMPT/mptrack/View_ins.cpp
===================================================================
--- trunk/OpenMPT/mptrack/View_ins.cpp	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/mptrack/View_ins.cpp	2009-09-06 12:45:07 UTC (rev 353)
@@ -1204,7 +1204,117 @@
 	return envelope->Ticks[EnvGetReleaseNode()];
 }
 
+bool CViewInstrument::EnvRemovePoint()
+//--------------------------------------
+{
+	CModDoc *pModDoc = GetDocument();
+	if ((pModDoc) && (m_nDragItem) && (m_nDragItem-1 <= EnvGetLastPoint()))
+	{
+		CSoundFile *pSndFile = pModDoc->GetSoundFile();
+		MODINSTRUMENT *pIns = pSndFile->Instruments[m_nInstrument];
+		if (pIns)
+		{
+			INSTRUMENTENVELOPE *envelope = GetEnvelopePtr();
+			if(envelope == nullptr || envelope->nNodes == 0) return false;
 
+			UINT nPoint = m_nDragItem - 1;
+
+			envelope->nNodes--;
+			for (UINT i=nPoint; i<envelope->nNodes; i++)
+			{
+				envelope->Ticks[i] = envelope->Ticks[i + 1];
+				envelope->Values[i] = envelope->Values[i + 1];
+			}
+			if (nPoint >= envelope->nNodes) nPoint = envelope->nNodes-1;
+			if (envelope->nLoopStart > nPoint) envelope->nLoopStart--;
+			if (envelope->nLoopEnd > nPoint) envelope->nLoopEnd--;
+			if (envelope->nSustainStart > nPoint) envelope->nSustainStart--;
+			if (envelope->nSustainEnd > nPoint) envelope->nSustainEnd--;
+			if (envelope->nReleaseNode>nPoint && envelope->nReleaseNode!=ENV_RELEASE_NODE_UNSET) envelope->nReleaseNode--;
+			envelope->Ticks[0] = 0;
+
+			pModDoc->SetModified();
+			pModDoc->UpdateAllViews(NULL, (m_nInstrument << HINT_SHIFT_INS) | HINT_ENVELOPE, NULL);
+			return true;
+		}
+	}
+	return false;
+}
+
+// Insert point. Returns 0 if error occured, else point ID + 1.
+UINT CViewInstrument::EnvInsertPoint()
+//------------------------------------
+{
+	CModDoc *pModDoc = GetDocument();
+	if (pModDoc)
+	{
+		CSoundFile *pSndFile = pModDoc->GetSoundFile();
+		MODINSTRUMENT *pIns = pSndFile->Instruments[m_nInstrument];
+		if (pIns)
+		{
+			int nTick = ScreenToTick(m_ptMenu.x);
+			int nValue = ScreenToValue(m_ptMenu.y);
+			if(nTick < 0) return false;
+
+			UINT maxpoints = (pSndFile->m_nType == MOD_TYPE_XM) ? 12 : 25;
+			//To check: Should there be MAX_ENVPOINTS?
+
+			nValue = CLAMP(nValue, 0, 64);
+
+			INSTRUMENTENVELOPE *envelope = GetEnvelopePtr();
+			if(envelope == nullptr) return false;
+			BYTE cDefaultValue;
+
+			switch(m_nEnv)
+			{
+			case ENV_VOLUME:
+				cDefaultValue = 64;
+				break;
+			case ENV_PANNING:
+				cDefaultValue = 32;
+				break;
+			case ENV_PITCH:
+				cDefaultValue = (pIns->dwFlags & ENV_FILTER) ? 64 : 32;
+				break;
+			default:
+				return false;
+			}
+
+			if (envelope->nNodes < maxpoints)
+			{
+				if (!envelope->nNodes)
+				{
+					envelope->Ticks[0] = 0;
+					envelope->Values[0] = cDefaultValue;
+					envelope->nNodes = 1;
+				}
+				UINT i = 0;
+				for (i = 0; i < envelope->nNodes; i++) if (nTick <= envelope->Ticks[i]) break;
+				for (UINT j = envelope->nNodes; j > i; j--)
+				{
+					envelope->Ticks[j] = envelope->Ticks[j - 1];
+					envelope->Values[j] = envelope->Values[j - 1];
+				}
+				envelope->Ticks[i] = (WORD)nTick;
+				envelope->Values[i] = (BYTE)nValue;
+				envelope->nNodes++;
+				if (envelope->nLoopStart >= i) envelope->nLoopStart++;
+				if (envelope->nLoopEnd >= i) envelope->nLoopEnd++;
+				if (envelope->nSustainStart >= i) envelope->nSustainStart++;
+				if (envelope->nSustainEnd >= i) envelope->nSustainEnd++;
+				if (envelope->nReleaseNode >= i && envelope->nReleaseNode != ENV_RELEASE_NODE_UNSET) envelope->nReleaseNode++;
+
+				pModDoc->SetModified();
+				pModDoc->UpdateAllViews(NULL, (m_nInstrument << HINT_SHIFT_INS) | HINT_ENVELOPE, NULL);
+				return i + 1;
+			}
+		}
+	}
+	return 0;
+}
+
+
+
 void CViewInstrument::DrawPositionMarks(HDC hdc)
 //----------------------------------------------
 {
@@ -1705,7 +1815,13 @@
 			if(CMainFrame::GetMainFrame()->GetInputHandler()->ShiftPressed())
 			{
 				m_ptMenu = pt;
-				OnEnvInsertPoint();
+				m_nDragItem = EnvInsertPoint(); // returns point ID + 1 if successful, else 0.
+				if(m_nDragItem > 0)
+				{
+					// Drag point if successful
+					SetCapture();
+					m_dwStatus |= INSSTATUS_DRAGGING;
+				}
 			}
 		}
 	}
@@ -1939,106 +2055,13 @@
 void CViewInstrument::OnEnvRemovePoint()
 //--------------------------------------
 {
-	CModDoc *pModDoc = GetDocument();
-	if ((pModDoc) && (m_nDragItem) && (m_nDragItem-1 <= EnvGetLastPoint()))
-	{
-		CSoundFile *pSndFile = pModDoc->GetSoundFile();
-		MODINSTRUMENT *pIns = pSndFile->Instruments[m_nInstrument];
-		if (pIns)
-		{
-			INSTRUMENTENVELOPE *envelope = GetEnvelopePtr();
-			if(envelope == nullptr || envelope->nNodes == 0) return;
-
-			UINT nPoint = m_nDragItem - 1;
-
-			envelope->nNodes--;
-			for (UINT i=nPoint; i<envelope->nNodes; i++)
-			{
-				envelope->Ticks[i] = envelope->Ticks[i + 1];
-				envelope->Values[i] = envelope->Values[i + 1];
-			}
-			if (nPoint >= envelope->nNodes) nPoint = envelope->nNodes-1;
-			if (envelope->nLoopStart > nPoint) envelope->nLoopStart--;
-			if (envelope->nLoopEnd > nPoint) envelope->nLoopEnd--;
-			if (envelope->nSustainStart > nPoint) envelope->nSustainStart--;
-			if (envelope->nSustainEnd > nPoint) envelope->nSustainEnd--;
-			if (envelope->nReleaseNode>nPoint && envelope->nReleaseNode!=ENV_RELEASE_NODE_UNSET) envelope->nReleaseNode--;
-			envelope->Ticks[0] = 0;
-
-			pModDoc->SetModified();
-			pModDoc->UpdateAllViews(NULL, (m_nInstrument << HINT_SHIFT_INS) | HINT_ENVELOPE, NULL);
-		}
-	}
+	EnvRemovePoint();
 }
 
-
 void CViewInstrument::OnEnvInsertPoint()
 //--------------------------------------
 {
-	CModDoc *pModDoc = GetDocument();
-	if (pModDoc)
-	{
-		CSoundFile *pSndFile = pModDoc->GetSoundFile();
-		MODINSTRUMENT *pIns = pSndFile->Instruments[m_nInstrument];
-		if (pIns)
-		{
-			int nTick = ScreenToTick(m_ptMenu.x);
-			int nValue = ScreenToValue(m_ptMenu.y);
-			if(nTick < 0) return;
-
-			UINT maxpoints = (pSndFile->m_nType == MOD_TYPE_XM) ? 12 : 25;
-			//To check: Should there be MAX_ENVPOINTS?
-
-			nValue = CLAMP(nValue, 0, 64);
-
-			INSTRUMENTENVELOPE *envelope = GetEnvelopePtr();
-			if(envelope == nullptr) return;
-			BYTE cDefaultValue;
-
-			switch(m_nEnv)
-			{
-				case ENV_VOLUME:
-					cDefaultValue = 64;
-					break;
-				case ENV_PANNING:
-					cDefaultValue = 32;
-					break;
-				case ENV_PITCH:
-					cDefaultValue = (pIns->dwFlags & ENV_FILTER) ? 64 : 32;
-					break;
-				default:
-					return;
-			}
-
-			if (envelope->nNodes < maxpoints)
-			{
-				if (!envelope->nNodes)
-				{
-					envelope->Ticks[0] = 0;
-					envelope->Values[0] = cDefaultValue;
-					envelope->nNodes = 1;
-				}
-				UINT i = 0;
-				for (i = 0; i < envelope->nNodes; i++) if (nTick <= envelope->Ticks[i]) break;
-				for (UINT j = envelope->nNodes; j > i; j--)
-				{
-					envelope->Ticks[j] = envelope->Ticks[j - 1];
-					envelope->Values[j] = envelope->Values[j - 1];
-				}
-				envelope->Ticks[i] = (WORD)nTick;
-				envelope->Values[i] = (BYTE)nValue;
-				envelope->nNodes++;
-				if (envelope->nLoopStart >= i) envelope->nLoopStart++;
-				if (envelope->nLoopEnd >= i) envelope->nLoopEnd++;
-				if (envelope->nSustainStart >= i) envelope->nSustainStart++;
-				if (envelope->nSustainEnd >= i) envelope->nSustainEnd++;
-				if (envelope->nReleaseNode >= i && envelope->nReleaseNode != ENV_RELEASE_NODE_UNSET) envelope->nReleaseNode++;
-
-				pModDoc->SetModified();
-				pModDoc->UpdateAllViews(NULL, (m_nInstrument << HINT_SHIFT_INS) | HINT_ENVELOPE, NULL);
-			}
-		}
-	}
+	EnvInsertPoint();
 }
 
 

Modified: trunk/OpenMPT/mptrack/View_ins.h
===================================================================
--- trunk/OpenMPT/mptrack/View_ins.h	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/mptrack/View_ins.h	2009-09-06 12:45:07 UTC (rev 353)
@@ -69,6 +69,8 @@
 	bool EnvSetPanEnv(bool bEnable);
 	bool EnvSetPitchEnv(bool bEnable);
 	bool EnvSetFilterEnv(bool bEnable);
+	UINT EnvInsertPoint();
+	bool EnvRemovePoint();
 	int TickToScreen(int nTick) const;
 	int PointToScreen(int nPoint) const;
 	int ScreenToTick(int x) const;

Modified: trunk/OpenMPT/mptrack/View_pat.cpp
===================================================================
--- trunk/OpenMPT/mptrack/View_pat.cpp	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/mptrack/View_pat.cpp	2009-09-06 12:45:07 UTC (rev 353)
@@ -29,6 +29,7 @@
 DWORD CViewPattern::m_dwReplaceFlags = 0;
 UINT CViewPattern::m_nFindMinChn = 0;
 UINT CViewPattern::m_nFindMaxChn = 0;
+signed char cInstrRelChange = 0;
 
 IMPLEMENT_SERIAL(CViewPattern, CModScrollView, 0)
 
@@ -1688,6 +1689,7 @@
 		pageReplace.m_nCommand = m_cmdReplace.command;
 		pageReplace.m_nParam = m_cmdReplace.param;
 		pageReplace.m_dwFlags = m_dwReplaceFlags;
+		pageReplace.cInstrRelChange = m_cInstrRelChange;
 		dlg.AddPage(&pageFind);
 		dlg.AddPage(&pageReplace);
 		if (dlg.DoModal() == IDOK)
@@ -1708,6 +1710,7 @@
 			m_cmdReplace.command = pageReplace.m_nCommand;
 			m_cmdReplace.param = pageReplace.m_nParam;
 			m_dwReplaceFlags = pageReplace.m_dwFlags;
+			m_cInstrRelChange = pageReplace.cInstrRelChange;
 			m_bContinueSearch = FALSE;
 			OnEditFindNext();
 		}
@@ -1866,7 +1869,7 @@
 				if (!(m_dwReplaceFlags & PATSEARCH_REPLACE)) goto EndSearch;
 				if (!(m_dwReplaceFlags & PATSEARCH_REPLACEALL))
 				{
-					UINT ans = MessageBox("Replace this occurrence ?", "Replace", MB_YESNOCANCEL);
+					UINT ans = MessageBox("Replace this occurrence?", "Replace", MB_YESNOCANCEL);
 					if (ans == IDYES) bReplace = TRUE; else
 					if (ans == IDNO) bReplace = FALSE; else goto EndSearch;
 				}
@@ -1875,22 +1878,22 @@
 					if ((m_dwReplaceFlags & PATSEARCH_NOTE))
 					{
 						// -1 octave
-						if (m_cmdReplace.note == CFindReplaceTab::replaceMinusOctave)
+						if (m_cmdReplace.note == CFindReplaceTab::replaceNoteMinusOctave)
 						{
 							if (m->note > 12) m->note -= 12;
 						} else
 						// +1 octave
-						if (m_cmdReplace.note == CFindReplaceTab::replacePlusOctave)
+						if (m_cmdReplace.note == CFindReplaceTab::replaceNotePlusOctave)
 						{
 							if (m->note <= NOTE_MAX - 12) m->note += 12;
 						} else
 						// Note--
-						if (m_cmdReplace.note == CFindReplaceTab::replaceMinusOne)
+						if (m_cmdReplace.note == CFindReplaceTab::replaceNoteMinusOne)
 						{
 							if (m->note > 1) m->note--;
 						} else
 						// Note++
-						if (m_cmdReplace.note == CFindReplaceTab::replacePlusOne)
+						if (m_cmdReplace.note == CFindReplaceTab::replaceNotePlusOne)
 						{
 							if (m->note < NOTE_MAX) m->note++;
 						} else m->note = m_cmdReplace.note;
@@ -1898,15 +1901,12 @@
 					if ((m_dwReplaceFlags & PATSEARCH_INSTR))
 					{
 						// Instr--
-						if (m_cmdReplace.instr == CFindReplaceTab::replaceMinusOne)
-						{
+						if (m_cInstrRelChange == -1)
 							if (m->instr > 1) m->instr--;
-						} else
 						// Instr++
-						if (m_cmdReplace.instr == CFindReplaceTab::replacePlusOne)
-						{
-							if (m->instr < MAX_INSTRUMENTS-1) m->instr++;
-						} else m->instr = m_cmdReplace.instr;
+						else if (m_cInstrRelChange == 1)
+							if (m->instr < MAX_INSTRUMENTS - 1) m->instr++;
+						else m->instr = m_cmdReplace.instr;
 					}
 					if ((m_dwReplaceFlags & PATSEARCH_VOLCMD))
 					{
@@ -3609,7 +3609,7 @@
 		case kcChangeLoopStatus: SendCtrlMessage(CTRLMSG_PAT_LOOP, -1); return wParam;
 		case kcNewPattern:		 SendCtrlMessage(CTRLMSG_PAT_NEWPATTERN); return wParam;
 		case kcSwitchToOrderList: OnSwitchToOrderList();
-		case kcSwitchEchoPaste:	CMainFrame::m_dwPatternSetup ^= PATTERN_ECHOPASTE; return wParam;
+		case kcSwitchOverflowPaste:	CMainFrame::m_dwPatternSetup ^= PATTERN_OVERFLOWPASTE; return wParam;
 
 	}
 	//Ranges:

Modified: trunk/OpenMPT/mptrack/View_pat.h
===================================================================
--- trunk/OpenMPT/mptrack/View_pat.h	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/mptrack/View_pat.h	2009-09-06 12:45:07 UTC (rev 353)
@@ -76,6 +76,7 @@
 	static MODCOMMAND m_cmdFind, m_cmdReplace, m_cmdOld;
 	static DWORD m_dwFindFlags, m_dwReplaceFlags;
 	static UINT m_nFindMinChn, m_nFindMaxChn;
+	signed char m_cInstrRelChange; // relative instrument change (quick'n'dirty fix)
 
 protected:
 	CFastBitmap m_Dib;

Modified: trunk/OpenMPT/mptrack/dlg_misc.cpp
===================================================================
--- trunk/OpenMPT/mptrack/dlg_misc.cpp	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/mptrack/dlg_misc.cpp	2009-09-06 12:45:07 UTC (rev 353)
@@ -667,10 +667,10 @@
 		combo->SetItemData(combo->AddString("..."), 0);
 		if (m_bReplace)
 		{
-			combo->SetItemData(combo->AddString("note-1"), replaceMinusOne);
-			combo->SetItemData(combo->AddString("note+1"), replacePlusOne);
-			combo->SetItemData(combo->AddString("-1 oct"), replaceMinusOctave);
-			combo->SetItemData(combo->AddString("+1 oct"), replacePlusOctave);
+			combo->SetItemData(combo->AddString("note-1"), replaceNoteMinusOne);
+			combo->SetItemData(combo->AddString("note+1"), replaceNotePlusOne);
+			combo->SetItemData(combo->AddString("-1 oct"), replaceNoteMinusOctave);
+			combo->SetItemData(combo->AddString("+1 oct"), replaceNotePlusOctave);
 		} else
 		{
 			combo->SetItemData(combo->AddString("any"), findAny);
@@ -690,8 +690,8 @@
 		combo->SetItemData(combo->AddString(".."), 0);
 		if (m_bReplace)
 		{
-			combo->SetItemData(combo->AddString("ins-1"), replaceMinusOne);
-			combo->SetItemData(combo->AddString("ins+1"), replacePlusOne);
+			combo->SetItemData(combo->AddString("ins-1"), replaceInstrumentMinusOne);
+			combo->SetItemData(combo->AddString("ins+1"), replaceInstrumentPlusOne);
 		}
 		for (UINT n=1; n<MAX_INSTRUMENTS; n++)
 		{
@@ -705,10 +705,13 @@
 			combo->SetItemData(combo->AddString(s), n);
 		}
 		UINT ncount = combo->GetCount();
-		for (UINT i=0; i<ncount; i++) if (m_nInstr == combo->GetItemData(i))
+		for (UINT i=0; i<ncount; i++)
 		{
-			combo->SetCurSel(i);
-			break;
+			if (m_nInstr == combo->GetItemData(i) || (cInstrRelChange == -1 && combo->GetItemData(i) == replaceInstrumentMinusOne) || (cInstrRelChange == 1 && combo->GetItemData(i) == replaceInstrumentPlusOne))
+			{
+				combo->SetCurSel(i);
+				break;
+			}
 		}
 	}
 	// Volume Command
@@ -844,7 +847,19 @@
 	// Instrument
 	if ((combo = (CComboBox *)GetDlgItem(IDC_COMBO2)) != NULL)
 	{
-		m_nInstr = combo->GetItemData(combo->GetCurSel());
+		switch(combo->GetItemData(combo->GetCurSel()))
+		{
+		case replaceInstrumentMinusOne:
+			cInstrRelChange = -1;
+			break;
+		case replaceInstrumentPlusOne:
+			cInstrRelChange = 1;
+			break;
+		default:
+			m_nInstr = combo->GetItemData(combo->GetCurSel());
+			cInstrRelChange = 0;
+			break;
+		}
 	}
 	// Volume Command
 	if (((combo = (CComboBox *)GetDlgItem(IDC_COMBO3)) != NULL) && (m_pModDoc))
@@ -1230,7 +1245,10 @@
 		AppendNotesToControlEx(*combo, pSndFile, m_nInstr);
 
 		if (m_nNote <= NOTE_MAX)
-			combo->SetCurSel(m_nNote);
+		{
+			const MODCOMMAND::NOTE noteStart = (pSndFile != nullptr) ? pSndFile->GetModSpecifications().noteMin : 1;
+			combo->SetCurSel(m_nNote - (noteStart - 1));
+		}
 		else
 		{
 			for(int i = combo->GetCount() - 1; i >= 0; --i)
@@ -1248,21 +1266,31 @@
 	if ((combo = (CComboBox *)GetDlgItem(IDC_COMBO2)) != NULL)
 	{
 		combo->ResetContent();
-		combo->SetItemData(combo->AddString("No Instrument"), 0);
-		UINT max = pSndFile->m_nInstruments;
-		if (!max) max = pSndFile->m_nSamples;
-		for (UINT i=1; i<=max; i++)
+
+		if(m_nNote == NOTE_PC || m_nNote == NOTE_PCS)
 		{
-			wsprintf(s, "%02d:", i);
-			int k = strlen(s);
-			if (pSndFile->m_nInstruments)
+			// control plugin param note
+			combo->SetItemData(combo->AddString("No Effect"), 0);
+			AddPluginNamesToCombobox(*combo, pSndFile->m_MixPlugins, false);
+		} else
+		{
+			// instrument / sample
+			combo->SetItemData(combo->AddString("No Instrument"), 0);
+			UINT max = max(pSndFile->m_nInstruments, pSndFile->m_nSamples); // instrument / sample mode
+			for (UINT i = 1; i <= max; i++)
 			{
-				if (pSndFile->Instruments[i])
-					memcpy(s+k, pSndFile->Instruments[i]->name, 32);
-			} else
-				memcpy(s+k, pSndFile->m_szNames[i], 32);
-			s[k+32] = 0;
-			combo->SetItemData(combo->AddString(s), i);
+				wsprintf(s, "%02d: ", i);
+				int k = strlen(s);
+				// instrument / sample
+				if (pSndFile->m_nInstruments)
+				{
+					if (pSndFile->Instruments[i])
+						memcpy(s+k, pSndFile->Instruments[i]->name, 32);
+				} else
+					memcpy(s+k, pSndFile->m_szNames[i], 32);
+				s[k+32] = 0;
+				combo->SetItemData(combo->AddString(s), i);
+			}
 		}
 		combo->SetCurSel(m_nInstr);
 	}
@@ -1272,6 +1300,8 @@
 void CPageEditNote::OnNoteChanged()
 //---------------------------------
 {
+	bool bWasParamControl = (m_nNote == NOTE_PC || m_nNote == NOTE_PCS) ? true : false;
+
 	CComboBox *combo;
 	if ((combo = (CComboBox *)GetDlgItem(IDC_COMBO1)) != NULL)
 	{
@@ -1294,6 +1324,10 @@
 			}
 		}
 	}
+	bool bIsNowParamControl = (m_nNote == NOTE_PC || m_nNote == NOTE_PCS) ? true : false;
+	if(bWasParamControl != bIsNowParamControl)
+		UpdateDialog();
+
 	if (m_pParent) m_pParent->UpdateNote(m_nNote, m_nInstr);
 }
 
@@ -1324,7 +1358,7 @@
 	if ((combo = (CComboBox *)GetDlgItem(IDC_COMBO1)) != NULL)
 	{
 		CSoundFile *pSndFile = m_pModDoc->GetSoundFile();
-		if (pSndFile->m_nType == MOD_TYPE_MOD)
+		if (pSndFile->m_nType == MOD_TYPE_MOD || m_bIsParamControl)
 		{
 			combo->EnableWindow(FALSE);
 			return;
@@ -1427,18 +1461,27 @@
 	pSndFile = m_pModDoc->GetSoundFile();
 	if ((combo = (CComboBox *)GetDlgItem(IDC_COMBO1)) != NULL)
 	{
-		UINT numfx = m_pModDoc->GetNumEffects();
-		UINT fxndx = m_pModDoc->GetIndexFromEffect(m_nCommand, m_nParam);
 		combo->ResetContent();
-		combo->SetItemData(combo->AddString(" None"), (DWORD)-1);
-		if (!m_nCommand) combo->SetCurSel(0);
-		for (UINT i=0; i<numfx; i++)
+		if(m_bIsParamControl)
 		{
-			if (m_pModDoc->GetEffectInfo(i, s, TRUE))
+			// plugin param control note
+			AddPluginParameternamesToCombobox(*combo, pSndFile->m_MixPlugins[m_nPlugin]);
+			combo->SetCurSel(m_nPluginParam);
+		} else
+		{
+			// process as effect
+			UINT numfx = m_pModDoc->GetNumEffects();
+			UINT fxndx = m_pModDoc->GetIndexFromEffect(m_nCommand, m_nParam);
+			combo->SetItemData(combo->AddString(" None"), (DWORD)-1);
+			if (!m_nCommand) combo->SetCurSel(0);
+			for (UINT i=0; i<numfx; i++)
 			{
-				int k = combo->AddString(s);
-				combo->SetItemData(k, i);
-				if (i == fxndx) combo->SetCurSel(k);
+				if (m_pModDoc->GetEffectInfo(i, s, TRUE))
+				{
+					int k = combo->AddString(s);
+					combo->SetItemData(k, i);
+					if (i == fxndx) combo->SetCurSel(k);
+				}
 			}
 		}
 	}

Modified: trunk/OpenMPT/mptrack/dlg_misc.h
===================================================================
--- trunk/OpenMPT/mptrack/dlg_misc.h	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/mptrack/dlg_misc.h	2009-09-06 12:45:07 UTC (rev 353)
@@ -133,6 +133,7 @@
 
 public:
 	UINT m_nNote, m_nInstr, m_nVolCmd, m_nVol, m_nCommand, m_nParam, m_nMinChannel, m_nMaxChannel;
+	signed char cInstrRelChange;
 	DWORD m_dwFlags;
 
 	enum findItem
@@ -143,10 +144,13 @@
 
 	enum replaceItem
 	{
-		replaceMinusOctave = NOTE_MIN_SPECIAL - 1,
-		replacePlusOctave = NOTE_MIN_SPECIAL - 2,
-		replaceMinusOne = NOTE_MIN_SPECIAL - 3,
-		replacePlusOne = NOTE_MIN_SPECIAL - 4
+		replaceNotePlusOne = NOTE_MAX + 1,
+		replaceNoteMinusOne = NOTE_MAX + 2,
+		replaceNotePlusOctave = NOTE_MAX + 3,
+		replaceNoteMinusOctave = NOTE_MAX + 4,
+
+		replaceInstrumentPlusOne = MAX_INSTRUMENTS + 1,
+		replaceInstrumentMinusOne = MAX_INSTRUMENTS + 2,
 	};
 
 	// Make sure there's unused notes between NOTE_MAX and NOTE_MIN_SPECIAL.
@@ -235,10 +239,11 @@
 {
 protected:
 	UINT m_nVolCmd, m_nVolume;
+	bool m_bIsParamControl;
 
 public:
 	CPageEditVolume(CModDoc *pModDoc, CEditCommand *parent):CPageEditCommand(pModDoc, parent, IDD_PAGEEDITVOLUME) {}
-	void Init(MODCOMMAND &m) { m_nVolCmd = m.volcmd; m_nVolume = m.vol; }
+	void Init(MODCOMMAND &m) { m_nVolCmd = m.volcmd; m_nVolume = m.vol; m_bIsParamControl = (m.note == NOTE_PC || m.note == NOTE_PCS) ? true : false;}
 	void UpdateDialog();
 	void UpdateRanges();
 
@@ -256,7 +261,9 @@
 //============================================
 {
 protected:
-	UINT m_nCommand, m_nParam;
+	UINT m_nCommand, m_nParam, m_nPlugin;
+	UINT m_nPluginParam;
+	bool m_bIsParamControl;
 // -> CODE#0010
 // -> DESC="add extended parameter mechanism to pattern effects"
 	UINT m_nXParam, m_nMultiplier;
@@ -268,7 +275,7 @@
 	CPageEditEffect(CModDoc *pModDoc, CEditCommand *parent):CPageEditCommand(pModDoc, parent, IDD_PAGEEDITEFFECT) {}
 // -> CODE#0010
 // -> DESC="add extended parameter mechanism to pattern effects"
-	void Init(MODCOMMAND &m) { m_nCommand = m.command; m_nParam = m.param; m_pModcommand = &m;}
+	void Init(MODCOMMAND &m) { m_nCommand = m.command; m_nParam = m.param; m_pModcommand = &m; m_bIsParamControl = (m.note == NOTE_PC || m.note == NOTE_PCS) ? true : false; m_nPlugin = m.instr; m_nPluginParam = MODCOMMAND::GetValueVolCol(m.volcmd, m.vol);}
 	void XInit(UINT xparam = 0, UINT multiplier = 1) { m_nXParam = xparam; m_nMultiplier = multiplier; }
 // -! NEW_FEATURE#0010
 	void UpdateDialog();

Modified: trunk/OpenMPT/mptrack/mptrack.rc
===================================================================
--- trunk/OpenMPT/mptrack/mptrack.rc	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/mptrack/mptrack.rc	2009-09-06 12:45:07 UTC (rev 353)
@@ -2120,7 +2120,7 @@
 BEGIN
     ID_EDIT_GOTO_MENU       "Go to row / channel / pattern / order"
     ID_CLEANUP_COMPO        "Reset attributes to defaults (useful for creating sample packs)\nCompo Cleanup"
-    ID_ECHOPASTE            "Toggle echo paste\nToggle echo paste"
+    ID_OVERFLOWPASTE        "Toggle overflow paste\nToggle overflow paste"
 END
 
 STRINGTABLE 

Modified: trunk/OpenMPT/mptrack/res/patterns.bmp
===================================================================
(Binary files differ)

Modified: trunk/OpenMPT/mptrack/resource.h
===================================================================
--- trunk/OpenMPT/mptrack/resource.h	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/mptrack/resource.h	2009-09-06 12:45:07 UTC (rev 353)
@@ -1113,7 +1113,7 @@
 #define ID_CLEANUP_COMPO                59221
 #define ID_SAMPLE_DRAW                  59224
 #define ID_SAMPLE_ADDSILENCE            59225
-#define ID_ECHOPASTE                    59226
+#define ID_OVERFLOWPASTE                59226
 #define ID_NOTEMAP_COPY_NOTE            59227
 #define ID_CLEANUP_REARRANGESAMPLES     59228
 

Modified: trunk/OpenMPT/soundlib/Load_it.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_it.cpp	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/soundlib/Load_it.cpp	2009-09-06 12:45:07 UTC (rev 353)
@@ -230,7 +230,7 @@
 		const ITOLDINSTRUMENT *pis = (const ITOLDINSTRUMENT *)p;
 		memcpy(pIns->name, pis->name, 26);
 		memcpy(pIns->filename, pis->filename, 12);
-		pIns->nFadeOut = pis->fadeout << 7;
+		pIns->nFadeOut = pis->fadeout << 6;
 		pIns->nGlobalVol = 64;
 		for (UINT j=0; j<NOTE_MAX; j++)
 		{

Modified: trunk/OpenMPT/soundlib/Load_psm.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_psm.cpp	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/soundlib/Load_psm.cpp	2009-09-06 12:45:07 UTC (rev 353)
@@ -776,7 +776,10 @@
 				for(uint32 nCell = 0; nCell < m_nChannels * Patterns[endPattern].GetNumRows(); nCell++)
 				{
 					if(row_data->command == CMD_PATTERNBREAK || row_data->command == CMD_POSITIONJUMP)
+					{
 						lastRow = nCell / m_nChannels;
+						break;
+					}
 					row_data++;
 				}
 				TryWriteEffect(endPattern, lastRow, CMD_POSITIONJUMP, (BYTE)subsongs[i].restartPos, false, CHANNELINDEX_INVALID, false, true);

Modified: trunk/OpenMPT/soundlib/Sampleio.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Sampleio.cpp	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/soundlib/Sampleio.cpp	2009-09-06 12:45:07 UTC (rev 353)
@@ -1324,7 +1324,7 @@
 	memcpy(xfh.extxi, "Extended Instrument: ", 21);
 	memcpy(xfh.name, pIns->name, 22);
 	xfh.name[22] = 0x1A;
-	memcpy(xfh.trkname, "FastTracker v2.00   ", 20);
+	memcpy(xfh.trkname, "Created by OpenMPT  ", 20);
 	xfh.shsize = 0x102;
 	fwrite(&xfh, 1, sizeof(xfh), f);
 	// XI Instrument Header

Modified: trunk/OpenMPT/soundlib/Sndmix.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Sndmix.cpp	2009-09-01 22:08:43 UTC (rev 352)
+++ trunk/OpenMPT/soundlib/Sndmix.cpp	2009-09-06 12:45:07 UTC (rev 353)
@@ -642,16 +642,18 @@
 			if ((m_nPattern < Patterns.Size()) && (!Patterns[m_nPattern])) m_nPattern = Order.GetIgnoreIndex();
 			while (m_nPattern >= Patterns.Size())
 			{
-				// End of song ?
+				// End of song?
 				if ((m_nPattern == Order.GetInvalidPatIndex()) || (m_nCurrentPattern >= Order.size()))
 				{
 
 					if (!m_nRepeatCount) return FALSE;
 
 					ORDERINDEX nRestartPosOverride = m_nRestartPos;
-					if(!m_nRestartPos && m_nCurrentPattern <= Order.size())
+					if(!m_nRestartPos && m_nCurrentPattern <= Order.size() && m_nCurrentPattern > 0)
 					{
-						// if we're in a subtune and there's no restart position, go to the first order of the subtune
+						/* Subtune detection. Subtunes are separated by "---" order items, so if we're in a
+						   subtune and there's no restart position, we go to the first order of the subtune
+						   (i.e. the first order after the previous "---" item) */
 						for(ORDERINDEX iOrd = m_nCurrentPattern - 1; iOrd > 0; iOrd--)
 						{
 							if(Order[iOrd] == Order.GetInvalidPatIndex())
@@ -709,7 +711,6 @@
 					//Handle Repeat position
 					if (m_nRepeatCount > 0) m_nRepeatCount--;
 					m_nCurrentPattern = nRestartPosOverride;
-					//m_nRow = 0;
 					m_dwSongFlags &= ~SONG_BREAKTOROW;
 					//If restart pos points to +++, move along
 					while (Order[m_nCurrentPattern] == Order.GetIgnoreIndex()) {


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-09-01 22:08:51

Revision: 352
          http://modplug.svn.sourceforge.net/modplug/?rev=352&view=rev
Author:   saga-games
Date:     2009-09-01 22:08:43 +0000 (Tue, 01 Sep 2009)

Log Message:
-----------
[Imp] S3M saver: Orderlist is now as small as possible (multiple of 2 instead of multiple of 16); Using ST3's default UltraClick value
[Imp] PSM loader: "Cosmetic" changes (use default values of first subtune for default speed/tempo/panning/etc., don't touch patterns if only one subtune is present.

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/Moddoc.cpp
    trunk/OpenMPT/mptrack/Mptrack.cpp
    trunk/OpenMPT/soundlib/Load_psm.cpp
    trunk/OpenMPT/soundlib/Load_s3m.cpp

Modified: trunk/OpenMPT/mptrack/Moddoc.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Moddoc.cpp	2009-09-01 18:50:33 UTC (rev 351)
+++ trunk/OpenMPT/mptrack/Moddoc.cpp	2009-09-01 22:08:43 UTC (rev 352)
@@ -2077,7 +2077,7 @@
 #define MOD_TYPE_XMIT	(MOD_TYPE_XM|MOD_TYPE_IT)
 #define MOD_TYPE_XMITMPT (MOD_TYPE_XM|MOD_TYPE_IT|MOD_TYPE_MPT)
 #define MOD_TYPE_ITMPT (MOD_TYPE_IT|MOD_TYPE_MPT)
-#define MAX_FXINFO		66					//rewbs.smoothVST, increased from 64... I wonder what this will break?
+#define MAX_FXINFO		68					//rewbs.smoothVST, increased from 64... I wonder what this will break?
 
 
 const MPTEFFECTINFO gFXInfo[MAX_FXINFO] =
@@ -2153,8 +2153,10 @@
 	{CMD_S3MCMDEX,		0xF0,0x70,	0,	MOD_TYPE_ITMPT,	"Instr. control"},
 // -> CODE#0010
 // -> DESC="add extended parameter mechanism to pattern effects"
-	{CMD_XPARAM,		0x00,0x00,	0,	MOD_TYPE_XMITMPT,	"X param"}
+	{CMD_XPARAM,		0x00,0x00,	0,	MOD_TYPE_XMITMPT,	"X param"},
 // -! NEW_FEATURE#0010
+	{CMD_NOTESLIDEUP,	0x00,0x00,	0,	0,	"Note Slide Up"}, // .IMF effect
+	{CMD_NOTESLIDEDOWN,	0x00,0x00,	0,	0,	"Note Slide Down"}, // .IMF effect
 };
 
 

Modified: trunk/OpenMPT/mptrack/Mptrack.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Mptrack.cpp	2009-09-01 18:50:33 UTC (rev 351)
+++ trunk/OpenMPT/mptrack/Mptrack.cpp	2009-09-01 22:08:43 UTC (rev 352)
@@ -1689,6 +1689,7 @@
 		"coda for sample drawing code|"
 		"http://coda.s3m.us/|"
 		"Storlek for all the IT compatibility hints and testcases|"
+		"as well as the IMF loader|"
 		"http://schismtracker.org/|"
 		"Pel K. Txnder for the scrolling credits control :)|"
 		"http://tinyurl.com/4yze8|"

Modified: trunk/OpenMPT/soundlib/Load_psm.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_psm.cpp	2009-09-01 18:50:33 UTC (rev 351)
+++ trunk/OpenMPT/soundlib/Load_psm.cpp	2009-09-01 22:08:43 UTC (rev 352)
@@ -283,13 +283,13 @@
 
 								case 0x07: // Default Speed
 									if(dwSettingsOffset - dwChunkPos + 2 > subChunkSize) break;
-									m_nDefaultSpeed = subsong.defaultSpeed = lpStream[dwSettingsOffset + 1];
+									subsong.defaultSpeed = lpStream[dwSettingsOffset + 1];
 									dwSettingsOffset += 2;
 									break;
 
 								case 0x08: // Default Tempo
 									if(dwSettingsOffset - dwChunkPos + 2 > subChunkSize) break;
-									m_nDefaultTempo =  subsong.defaultTempo =  lpStream[dwSettingsOffset + 1];
+									subsong.defaultTempo =  lpStream[dwSettingsOffset + 1];
 									dwSettingsOffset += 2;
 									break;
 
@@ -313,20 +313,17 @@
 										switch(lpStream[dwSettingsOffset + 3])
 										{
 										case 0: // use panning
-											ChnSettings[nChn].nPan = subsong.channelPanning[nChn] = lpStream[dwSettingsOffset + 2] ^ 128;
-											ChnSettings[nChn].dwFlags &= ~CHN_SURROUND;
+											subsong.channelPanning[nChn] = lpStream[dwSettingsOffset + 2] ^ 128;
 											subsong.channelSurround[nChn] = false;
 											break;
 
 										case 2: // surround
-											ChnSettings[nChn].nPan = subsong.channelPanning[nChn] = 128;
-											ChnSettings[nChn].dwFlags |= CHN_SURROUND;
+											subsong.channelPanning[nChn] = 128;
 											subsong.channelSurround[nChn] = true;
 											break;
 
 										case 4: // center
-											ChnSettings[nChn].nPan = subsong.channelPanning[nChn] = 128;
-											ChnSettings[nChn].dwFlags &= ~CHN_SURROUND;
+											subsong.channelPanning[nChn] = 128;
 											subsong.channelSurround[nChn] = false;
 											break;
 
@@ -341,10 +338,10 @@
 									dwSettingsOffset += 4;
 									break;
 
-								case 0x0E: // Channel volume table (0...255)
+								case 0x0E: // Channel volume table (0...255) - apparently always 255
 									if(dwSettingsOffset - dwChunkPos + 3 > subChunkSize) break;
 									if(lpStream[dwSettingsOffset + 1] < MAX_BASECHANNELS)
-										ChnSettings[lpStream[dwSettingsOffset + 1]].nVolume = subsong.channelVolume[lpStream[dwSettingsOffset + 1]] = (lpStream[dwSettingsOffset + 2] >> 2) + 1;
+										subsong.channelVolume[lpStream[dwSettingsOffset + 1]] = (lpStream[dwSettingsOffset + 2] >> 2) + 1;
 
 									dwSettingsOffset += 3;
 									break;
@@ -375,20 +372,17 @@
 							switch(lpStream[dwChunkPos + i])
 							{
 							case 0: // use panning
-								ChnSettings[nChn].nPan = subsong.channelPanning[nChn] = lpStream[dwChunkPos + i + 1] ^ 128;
-								ChnSettings[nChn].dwFlags &= ~CHN_SURROUND;
+								subsong.channelPanning[nChn] = lpStream[dwChunkPos + i + 1] ^ 128;
 								subsong.channelSurround[nChn] = false;
 								break;
 
 							case 2: // surround
-								ChnSettings[nChn].nPan = subsong.channelPanning[nChn] = 128;
-								ChnSettings[nChn].dwFlags |= CHN_SURROUND;
+								subsong.channelPanning[nChn] = 128;
 								subsong.channelSurround[nChn] = true;
 								break;
 
 							case 4: // center
-								ChnSettings[nChn].nPan = subsong.channelPanning[nChn] = 128;
-								ChnSettings[nChn].dwFlags &= ~CHN_SURROUND;
+								subsong.channelPanning[nChn] = 128;
 								subsong.channelSurround[nChn] = false;
 								break;
 							}
@@ -478,9 +472,23 @@
 		dwMemPos += chunkSize;
 	}
 
-	if(m_nChannels == 0)
+	if(m_nChannels == 0 || subsongs.size() == 0)
 		return false;
 
+	// Make the default variables of the first subsong global
+	m_nDefaultSpeed = subsongs[0].defaultSpeed;
+	m_nDefaultTempo = subsongs[0].defaultTempo;
+	m_nRestartPos = subsongs[0].restartPos;
+	for(CHANNELINDEX nChn = 0; nChn < m_nChannels; nChn++)
+	{
+		ChnSettings[nChn].nVolume = subsongs[0].channelVolume[nChn];
+		ChnSettings[nChn].nPan = subsongs[0].channelPanning[nChn];
+		if(subsongs[0].channelSurround[nChn])
+			ChnSettings[nChn].dwFlags |= CHN_SURROUND;
+		else
+			ChnSettings[nChn].dwFlags &= ~CHN_SURROUND;
+	}
+
 	// Now that we know the number of channels, we can go through all the patterns.
 	// This is a bit stupid since we will even read duplicate patterns twice, but hey, we do this just once... so who cares?
 	PATTERNINDEX nPat = 0;
@@ -582,7 +590,7 @@
 					case 0x04: // volslide down
 						command = CMD_VOLUMESLIDE;
 						if (bNewFormat) param &= 0x0F;
-						else param = (param >> 1) & 0x0F;
+						else if(param < 2) param |= 0xF0; else param = (param >> 1) & 0x0F;
 						break;
 
 					// Portamento
@@ -728,48 +736,51 @@
 		nPat++;
 	}
 
-	// write subsong "configuration" to patterns
-	for(uint32 i = 0; i < subsongs.size(); i++)
+	if(subsongs.size() > 1)
 	{
-		PATTERNINDEX startPattern = Order[subsongs[i].startOrder], endPattern = Order[subsongs[i].endOrder];
-		if(startPattern == PATTERNINDEX_INVALID || endPattern == PATTERNINDEX_INVALID) continue; // what, invalid subtune?
+		// write subsong "configuration" to patterns (only if there are multiple subsongs)
+		for(uint32 i = 0; i < subsongs.size(); i++)
+		{
+			PATTERNINDEX startPattern = Order[subsongs[i].startOrder], endPattern = Order[subsongs[i].endOrder];
+			if(startPattern == PATTERNINDEX_INVALID || endPattern == PATTERNINDEX_INVALID) continue; // what, invalid subtune?
 
-		// set the subsong name to all pattern names
-		for(PATTERNINDEX nPat = startPattern; nPat <= endPattern; nPat++)
-		{
-			SetPatternName(nPat, subsongs[i].songName);
-		}
-		
-		// subsongs with different panning setup -> write to pattern (MUSIC_C.PSM)
-		if(bSubsongPanningDiffers)
-		{
-			for(CHANNELINDEX nChn = 0; nChn < m_nChannels; nChn++)
+			// set the subsong name to all pattern names
+			for(PATTERNINDEX nPat = startPattern; nPat <= endPattern; nPat++)
 			{
-				if(subsongs[i].channelSurround[nChn] == true)
-					TryWriteEffect(startPattern, 0, CMD_S3MCMDEX, 0x91, false, nChn, false, true);
-				else
-					TryWriteEffect(startPattern, 0, CMD_PANNING8, subsongs[i].channelPanning[nChn], false, nChn, false, true);
+				SetPatternName(nPat, subsongs[i].songName);
 			}
-		}
-		// write default tempo/speed to pattern
-		TryWriteEffect(startPattern, 0, CMD_SPEED, subsongs[i].defaultSpeed, false, CHANNELINDEX_INVALID, false, true);
-		TryWriteEffect(startPattern, 0, CMD_TEMPO, subsongs[i].defaultTempo, false, CHANNELINDEX_INVALID, false, true);
 
-		// don't write channel volume for now, as it's always set to 100% anyway
+			// subsongs with different panning setup -> write to pattern (MUSIC_C.PSM)
+			if(bSubsongPanningDiffers)
+			{
+				for(CHANNELINDEX nChn = 0; nChn < m_nChannels; nChn++)
+				{
+					if(subsongs[i].channelSurround[nChn] == true)
+						TryWriteEffect(startPattern, 0, CMD_S3MCMDEX, 0x91, false, nChn, false, true);
+					else
+						TryWriteEffect(startPattern, 0, CMD_PANNING8, subsongs[i].channelPanning[nChn], false, nChn, false, true);
+				}
+			}
+			// write default tempo/speed to pattern
+			TryWriteEffect(startPattern, 0, CMD_SPEED, subsongs[i].defaultSpeed, false, CHANNELINDEX_INVALID, false, true);
+			TryWriteEffect(startPattern, 0, CMD_TEMPO, subsongs[i].defaultTempo, false, CHANNELINDEX_INVALID, false, true);
 
-		// there's a restart pos, so let's try to insert a Bxx command in the last pattern
-		if(subsongs[i].restartPos != ORDERINDEX_INVALID)
-		{
-			ROWINDEX lastRow = Patterns[endPattern].GetNumRows() - 1;
-			MODCOMMAND *row_data;
-			row_data = Patterns[endPattern];
-			for(uint32 nCell = 0; nCell < m_nChannels * Patterns[endPattern].GetNumRows(); nCell++)
+			// don't write channel volume for now, as it's always set to 100% anyway
+
+			// there's a restart pos, so let's try to insert a Bxx command in the last pattern
+			if(subsongs[i].restartPos != ORDERINDEX_INVALID)
 			{
-				if(row_data->command == CMD_PATTERNBREAK || row_data->command == CMD_POSITIONJUMP)
-					lastRow = nCell / m_nChannels;
-				row_data++;
+				ROWINDEX lastRow = Patterns[endPattern].GetNumRows() - 1;
+				MODCOMMAND *row_data;
+				row_data = Patterns[endPattern];
+				for(uint32 nCell = 0; nCell < m_nChannels * Patterns[endPattern].GetNumRows(); nCell++)
+				{
+					if(row_data->command == CMD_PATTERNBREAK || row_data->command == CMD_POSITIONJUMP)
+						lastRow = nCell / m_nChannels;
+					row_data++;
+				}
+				TryWriteEffect(endPattern, lastRow, CMD_POSITIONJUMP, (BYTE)subsongs[i].restartPos, false, CHANNELINDEX_INVALID, false, true);
 			}
-			TryWriteEffect(endPattern, lastRow, CMD_POSITIONJUMP, (BYTE)subsongs[i].restartPos, false, CHANNELINDEX_INVALID, false, true);
 		}
 	}
 

Modified: trunk/OpenMPT/soundlib/Load_s3m.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_s3m.cpp	2009-09-01 18:50:33 UTC (rev 351)
+++ trunk/OpenMPT/soundlib/Load_s3m.cpp	2009-09-01 22:08:43 UTC (rev 352)
@@ -527,7 +527,6 @@
 		nbo = 2;
 	else if (nbo & 1) // number of orders must be even
 		nbo++;
-	nbo = (nbo + 15) & 0xF0; // TODO why does it not work otherwise? nbo should be multiple of 2, not 16!
 	if(nbo > 0xF0) nbo = 0xF0; // sequence too long
 	header[0x20] = nbo & 0xFF;
 	header[0x21] = nbo >> 8;
@@ -560,7 +559,7 @@
 	header[0x31] = CLAMP(m_nDefaultSpeed, 1, 255);
 	header[0x32] = CLAMP(m_nDefaultTempo, 32, 255);
 	header[0x33] = CLAMP(m_nSamplePreAmp, 0x10, 0x7F) | 0x80;	// Bit 8 = Stereo
-	header[0x34] = 0x10; // 16 Channels for UltraClick removal
+	header[0x34] = 0x08; // 8 Channels for UltraClick removal (default)
 	header[0x35] = 0xFC; // Write pan positions
 	for (i=0; i<32; i++)
 	{
@@ -571,7 +570,7 @@
 		} else header[0x40+i] = 0xFF;
 	}
 	fwrite(header, 0x60, 1, f);
-	Order.WriteAsByte(f, nbo);
+	nbo = Order.WriteAsByte(f, nbo);
 	memset(patptr, 0, sizeof(patptr));
 	memset(insptr, 0, sizeof(insptr));
 	UINT ofs0 = 0x60 + nbo;
@@ -595,6 +594,7 @@
 	{
 		fwrite(S3MFiller, 0x10 - ((nbi*2+nbp*2) & 0x0F), 1, f);
 	}
+	fseek(f, ofs1, SEEK_SET);
 	ofs1 = ftell(f);
 	fwrite(insex, nbi, 0x50, f);
 	// Packing patterns


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <rel...@us...> - 2009-09-01 18:50:54

Revision: 351
          http://modplug.svn.sourceforge.net/modplug/?rev=351&view=rev
Author:   relabsoluness
Date:     2009-09-01 18:50:33 +0000 (Tue, 01 Sep 2009)

Log Message:
-----------
[Ref] Moved constants from Sndfile.h to a new file, renamed OrderToPatternTable files, added some utility functions, minor code cleanup.

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/misc_util.h
    trunk/OpenMPT/mptrack/mptrack.vcproj
    trunk/OpenMPT/mptrack/mptrack_08.vcproj
    trunk/OpenMPT/mptrack/typedefs.h
    trunk/OpenMPT/soundlib/Sndfile.h
    trunk/OpenMPT/soundlib/mod_specifications.h
    trunk/OpenMPT/soundlib/pattern.h
    trunk/OpenMPT/soundlib/patternContainer.h

Added Paths:
-----------
    trunk/OpenMPT/soundlib/ModSequence.cpp
    trunk/OpenMPT/soundlib/ModSequence.h
    trunk/OpenMPT/soundlib/Snd_defs.h

Removed Paths:
-------------
    trunk/OpenMPT/soundlib/OrderToPatternTable.cpp
    trunk/OpenMPT/soundlib/OrderToPatternTable.h

Modified: trunk/OpenMPT/mptrack/misc_util.h
===================================================================
--- trunk/OpenMPT/mptrack/misc_util.h	2009-08-30 22:27:15 UTC (rev 350)
+++ trunk/OpenMPT/mptrack/misc_util.h	2009-09-01 18:50:33 UTC (rev 351)
@@ -81,4 +81,33 @@
  
 LPCCH LoadResource(LPCTSTR lpName, LPCTSTR lpType, LPCCH& pData, size_t& nSize, HGLOBAL& hglob);
 
+namespace utilImpl
+{
+	template <bool bMemcpy>
+	struct ArrayCopyImpl {};
+
+	template <>
+	struct ArrayCopyImpl<true>
+	{
+		template <class T>
+		static void Do(T* pDst, const T* pSrc, const size_t n) {memcpy(pDst, pSrc, sizeof(T) * n);}
+	};
+
+	template <>
+	struct ArrayCopyImpl<false>
+	{
+		template <class T>
+		static void Do(T* pDst, const T* pSrc, const size_t n) {std::copy(pSrc, pSrc + n, pDst);}
+	};
+} // namespace utilImpl
+
+
+// Copies n elements from array pSrc to array pDst.
+// If the source and destination arrays overlap, behaviour is undefined.
+template <class T>
+void ArrayCopy(T* pDst, const T* pSrc, const size_t n)
+{
+	utilImpl::ArrayCopyImpl<std::tr1::has_trivial_assign<T>::value>::Do(pDst, pSrc, n);
+}
+
 #endif

Modified: trunk/OpenMPT/mptrack/mptrack.vcproj
===================================================================
--- trunk/OpenMPT/mptrack/mptrack.vcproj	2009-08-30 22:27:15 UTC (rev 350)
+++ trunk/OpenMPT/mptrack/mptrack.vcproj	2009-09-01 18:50:33 UTC (rev 351)
@@ -367,6 +367,9 @@
 				RelativePath=".\Modedit.cpp">
 			</File>
 			<File
+				RelativePath="..\soundlib\ModSequence.cpp">
+			</File>
+			<File
 				RelativePath="..\soundlib\modsmp_ctrl.cpp">
 			</File>
 			<File
@@ -397,9 +400,6 @@
 				RelativePath=".\OpenGLEditor.cpp">
 			</File>
 			<File
-				RelativePath="..\soundlib\OrderToPatternTable.cpp">
-			</File>
-			<File
 				RelativePath="..\soundlib\pattern.cpp">
 			</File>
 			<File
@@ -795,6 +795,9 @@
 				RelativePath=".\moddoc.h">
 			</File>
 			<File
+				RelativePath="..\soundlib\ModSequence.h">
+			</File>
+			<File
 				RelativePath="..\soundlib\modsmp_ctrl.h">
 			</File>
 			<File
@@ -819,12 +822,6 @@
 				RelativePath=".\OpenGLEditor.h">
 			</File>
 			<File
-				RelativePath=".\order.h">
-			</File>
-			<File
-				RelativePath="..\soundlib\OrderToPatternTable.h">
-			</File>
-			<File
 				RelativePath="..\soundlib\pattern.h">
 			</File>
 			<File
@@ -852,6 +849,9 @@
 				RelativePath=".\serialization_utils.h">
 			</File>
 			<File
+				RelativePath="..\soundlib\Snd_defs.h">
+			</File>
+			<File
 				RelativePath="..\Soundlib\snddev.h">
 			</File>
 			<File

Modified: trunk/OpenMPT/mptrack/mptrack_08.vcproj
===================================================================
--- trunk/OpenMPT/mptrack/mptrack_08.vcproj	2009-08-30 22:27:15 UTC (rev 350)
+++ trunk/OpenMPT/mptrack/mptrack_08.vcproj	2009-09-01 18:50:33 UTC (rev 351)
@@ -493,6 +493,10 @@
 				>
 			</File>
 			<File
+				RelativePath="..\soundlib\ModSequence.cpp"
+				>
+			</File>
+			<File
 				RelativePath="..\soundlib\modsmp_ctrl.cpp"
 				>
 			</File>
@@ -533,10 +537,6 @@
 				>
 			</File>
 			<File
-				RelativePath="..\soundlib\OrderToPatternTable.cpp"
-				>
-			</File>
-			<File
 				RelativePath="..\soundlib\pattern.cpp"
 				>
 			</File>
@@ -1051,6 +1051,10 @@
 				>
 			</File>
 			<File
+				RelativePath="..\soundlib\ModSequence.h"
+				>
+			</File>
+			<File
 				RelativePath="..\soundlib\modsmp_ctrl.h"
 				>
 			</File>
@@ -1083,14 +1087,6 @@
 				>
 			</File>
 			<File
-				RelativePath=".\order.h"
-				>
-			</File>
-			<File
-				RelativePath="..\soundlib\OrderToPatternTable.h"
-				>
-			</File>
-			<File
 				RelativePath="..\soundlib\pattern.h"
 				>
 			</File>
@@ -1127,6 +1123,10 @@
 				>
 			</File>
 			<File
+				RelativePath="..\soundlib\Snd_defs.h"
+				>
+			</File>
+			<File
 				RelativePath="..\Soundlib\snddev.h"
 				>
 			</File>

Modified: trunk/OpenMPT/mptrack/typedefs.h
===================================================================
--- trunk/OpenMPT/mptrack/typedefs.h	2009-08-30 22:27:15 UTC (rev 350)
+++ trunk/OpenMPT/mptrack/typedefs.h	2009-09-01 18:50:33 UTC (rev 351)
@@ -31,26 +31,26 @@
 typedef float float32;
 
 
-typedef uint32 ROWINDEX;
-	const ROWINDEX ROWINDEX_MAX = uint32_max;
-typedef uint16 CHANNELINDEX;
-	const CHANNELINDEX CHANNELINDEX_MAX	= uint16_max;
-	const CHANNELINDEX CHANNELINDEX_INVALID	= CHANNELINDEX_MAX;
-typedef uint16 ORDERINDEX;
-	const ORDERINDEX ORDERINDEX_MAX	= uint16_max;
-	const ORDERINDEX ORDERINDEX_INVALID	= ORDERINDEX_MAX;
-typedef uint16 PATTERNINDEX;
-	const PATTERNINDEX PATTERNINDEX_MAX	= uint16_max;
-	const PATTERNINDEX PATTERNINDEX_INVALID	= PATTERNINDEX_MAX;
-typedef uint8  PLUGINDEX;
-typedef uint16 TEMPO;
-typedef uint16 SAMPLEINDEX;
-	const SAMPLEINDEX SAMPLEINDEX_MAX	= uint16_max;
-	const SAMPLEINDEX SAMPLEINDEX_INVALID	= SAMPLEINDEX_MAX;
-typedef uint16 INSTRUMENTINDEX;
-	const SAMPLEINDEX INSTRUMENTINDEX_MAX	= uint16_max;
-	const SAMPLEINDEX INSTRUMENTINDEX_INVALID	= INSTRUMENTINDEX_MAX;
-typedef uint32 MODTYPE;
+#if !_HAS_TR1
+	namespace std
+	{ 
+		namespace tr1
+		{
+			template <class T> struct has_trivial_assign {static const bool value = false;};
 
+			#define SPECIALIZE_TRIVIAL_ASSIGN(type) template <> struct has_trivial_assign<type> {static const bool value = true;}
+			SPECIALIZE_TRIVIAL_ASSIGN(int8);
+			SPECIALIZE_TRIVIAL_ASSIGN(uint8);
+			SPECIALIZE_TRIVIAL_ASSIGN(int16);
+			SPECIALIZE_TRIVIAL_ASSIGN(uint16);
+			SPECIALIZE_TRIVIAL_ASSIGN(int32);
+			SPECIALIZE_TRIVIAL_ASSIGN(uint32);
+			SPECIALIZE_TRIVIAL_ASSIGN(int64);
+			SPECIALIZE_TRIVIAL_ASSIGN(uint64);
+			#undef SPECIALIZE_TRIVIAL_ASSIGN
+		};
+	};
+#endif
 
+
 #endif

Copied: trunk/OpenMPT/soundlib/ModSequence.cpp (from rev 349, trunk/OpenMPT/soundlib/OrderToPatternTable.cpp)
===================================================================
--- trunk/OpenMPT/soundlib/ModSequence.cpp	                        (rev 0)
+++ trunk/OpenMPT/soundlib/ModSequence.cpp	2009-09-01 18:50:33 UTC (rev 351)
@@ -0,0 +1,221 @@
+#include "stdafx.h"
+#include "sndfile.h"
+#include "ModSequence.h"
+#include "../mptrack/serialization_utils.h"
+
+#define str_SequenceTruncationNote (GetStrI18N((_TEXT("Module has sequence of length %u; it will be truncated to maximum supported length, %u."))))
+
+DWORD COrderToPatternTable::Deserialize(const BYTE* const src, const DWORD memLength)
+//-------------------------------------------------------------------------
+{
+	if(memLength < 2 + 4) return 0;
+	uint16 version = 0;
+	uint32 s = 0;
+	DWORD memPos = 0;
+	memcpy(&version, src, sizeof(version));
+	memPos += sizeof(version);
+	if(version != 0) return memPos;
+    memcpy(&s, src+memPos, sizeof(s));
+	memPos += sizeof(s);
+	if(s > 65000) return true;
+	if(memLength < memPos+s*4) return memPos;
+
+	const uint32 nOriginalSize = s;
+	if(s > ModSpecs::mptm.ordersMax)
+		s = ModSpecs::mptm.ordersMax;
+
+	resize(max(s, MAX_ORDERS));
+	for(size_t i = 0; i<s; i++, memPos +=4 )
+	{
+		uint32 temp;
+		memcpy(&temp, src+memPos, 4);
+		(*this)[i] = static_cast<PATTERNINDEX>(temp);
+	}
+	memPos += 4*(nOriginalSize - s);
+	return memPos;
+}
+
+
+size_t COrderToPatternTable::WriteToByteArray(BYTE* dest, const UINT numOfBytes, const UINT destSize)
+//-----------------------------------------------------------------------------
+{
+	if(numOfBytes > destSize) return true;
+	if(size() < numOfBytes) resize(numOfBytes, 0xFF);
+	UINT i = 0;
+	for(i = 0; i<numOfBytes; i++)
+	{
+		dest[i] = static_cast<BYTE>((*this)[i]);
+	}
+	return i; //Returns the number of bytes written.
+}
+
+
+size_t COrderToPatternTable::WriteAsByte(FILE* f, const UINT count)
+//---------------------------------------------------------------
+{
+	if(size() < count) resize(count, GetInvalidPatIndex());
+
+	size_t i = 0;
+	
+	for(i = 0; i<count; i++)
+	{
+		const PATTERNINDEX pat = (*this)[i];
+		BYTE temp = static_cast<BYTE>((*this)[i]);
+
+		if(pat > 0xFD)
+		{
+			if(pat == GetInvalidPatIndex()) temp = 0xFF;
+			else temp = 0xFE;
+		}
+		fwrite(&temp, 1, 1, f);
+	}
+	return i; //Returns the number of bytes written.
+}
+
+bool COrderToPatternTable::ReadAsByte(const BYTE* pFrom, const int howMany, const int memLength)
+//-------------------------------------------------------------------------
+{
+	if(howMany < 0 || howMany > memLength) return true;
+	if(m_rSndFile.GetType() != MOD_TYPE_MPT && howMany > MAX_ORDERS) return true;
+	
+	if(size() < static_cast<size_t>(howMany))
+		resize(howMany, GetInvalidPatIndex());
+	
+	for(int i = 0; i<howMany; i++, pFrom++)
+		(*this)[i] = *pFrom;
+	return false;
+}
+
+
+bool COrderToPatternTable::NeedsExtraDatafield() const
+//----------------------------------------------
+{
+	if(m_rSndFile.GetType() == MOD_TYPE_MPT && m_rSndFile.Patterns.Size() > 0xFD)
+		return true;
+	else
+		return false;
+}
+
+
+void COrderToPatternTable::OnModTypeChanged(const MODTYPE oldtype)
+//----------------------------------------------------------------
+{
+	const CModSpecifications specs = m_rSndFile.GetModSpecifications();
+
+	//Resize orderlist if needed. Because old orderlist had MAX_ORDERS(256) elements, not making it
+	//smaller than that even if the modtype doesn't support that many orders.
+	if(specs.ordersMax < GetCount()) 
+	{
+		resize(max(MAX_ORDERS, specs.ordersMax));
+		for(ORDERINDEX i = GetCount(); i>specs.ordersMax; --i) (*this)[i-1] = GetInvalidPatIndex();
+	}
+	if (GetCount() < MAX_ORDERS)
+		resize(MAX_ORDERS, GetInvalidPatIndex());
+
+	//Replace items used to denote end of song/skip order.
+	replace(begin(), end(), GetInvalidPatIndex(oldtype), GetInvalidPatIndex());
+	replace(begin(), end(), GetIgnoreIndex(oldtype), GetIgnoreIndex());
+}
+
+
+ORDERINDEX COrderToPatternTable::GetLengthTailTrimmed() const
+//-----------------------------------------------------------
+{
+	ORDERINDEX nEnd = GetCount();
+	if(nEnd == 0) return 0;
+	nEnd--;
+	const PATTERNINDEX iInvalid = GetInvalidPatIndex();
+	while(nEnd > 0 && (*this)[nEnd] == iInvalid)
+		nEnd--;
+	return ((*this)[nEnd] == iInvalid) ? 0 : nEnd+1;
+}
+
+
+ORDERINDEX COrderToPatternTable::GetLengthFirstEmpty() const
+//----------------------------------------------------------
+{
+	const ORDERINDEX nLength = GetCount();
+	ORDERINDEX nMax = 0;
+	while ((nMax < nLength) && ((*this)[nMax] != (*this).GetInvalidPatIndex())) nMax++;
+	return nMax;
+}
+
+
+ORDERINDEX COrderToPatternTable::GetNextOrderIgnoringSkips(const ORDERINDEX start) const
+//-------------------------------------------------------------------------------------
+{
+	const ORDERINDEX count = GetCount();
+	if(count == 0) return 0;
+	ORDERINDEX next = min(count-1, start+1);
+	while(next+1 < count && (*this)[next] == GetIgnoreIndex()) next++;
+	return next;
+}
+
+ORDERINDEX COrderToPatternTable::GetPreviousOrderIgnoringSkips(const ORDERINDEX start) const
+//-------------------------------------------------------------------------------------
+{
+	const ORDERINDEX count = GetCount();
+	if(start == 0 || count == 0) return 0;
+	ORDERINDEX prev = min(start-1, count-1);
+	while(prev > 0 && (*this)[prev] == GetIgnoreIndex()) prev--;
+	return prev;
+}
+
+
+void COrderToPatternTable::Init()
+//-------------------------------
+{
+	resize(MAX_ORDERS, GetInvalidPatIndex());
+	for(ORDERINDEX i = 0; i < GetCount(); i++)
+	{
+		(*this)[i] = GetInvalidPatIndex();
+	}
+}
+
+
+
+PATTERNINDEX COrderToPatternTable::GetInvalidPatIndex(const MODTYPE type) {return type == MOD_TYPE_MPT ?  65535 : 0xFF;}
+PATTERNINDEX COrderToPatternTable::GetIgnoreIndex(const MODTYPE type) {return type == MOD_TYPE_MPT ? 65534 : 0xFE;}
+
+PATTERNINDEX COrderToPatternTable::GetInvalidPatIndex() const {return GetInvalidPatIndex(m_rSndFile.GetType());}
+PATTERNINDEX COrderToPatternTable::GetIgnoreIndex() const {return GetIgnoreIndex(m_rSndFile.GetType());}
+
+
+void ReadModSequence(std::istream& iStrm, COrderToPatternTable& seq, const size_t)
+//--------------------------------------------------------------------------------
+{
+	uint16 size;
+	srlztn::Binaryread<uint16>(iStrm, size);
+	if(size > ModSpecs::mptm.ordersMax)
+	{
+		// Hack: Show message here if trying to load longer sequence than what is supported.
+		CString str; str.Format(str_SequenceTruncationNote, size, ModSpecs::mptm.ordersMax);
+		AfxMessageBox(str, MB_ICONWARNING);
+		size = ModSpecs::mptm.ordersMax;
+	}
+	seq.resize(max(size, MAX_ORDERS), seq.GetInvalidPatIndex());
+	if(size == 0)
+		{ seq.Init(); return; }
+
+	for(size_t i = 0; i < size; i++)
+	{
+		uint16 temp;
+		srlztn::Binaryread<uint16>(iStrm, temp);
+		seq[i] = temp;
+	}
+}
+
+
+void WriteModSequence(std::ostream& oStrm, const COrderToPatternTable& seq)
+//-------------------------------------------------------------------------
+{
+	uint16 size = seq.GetCount();
+	srlztn::Binarywrite<uint16>(oStrm, size);
+	const COrderToPatternTable::const_iterator endIter = seq.end();
+	for(COrderToPatternTable::const_iterator citer = seq.begin(); citer != endIter; citer++)
+	{
+		const uint16 temp = static_cast<uint16>(*citer);
+		srlztn::Binarywrite<uint16>(oStrm, temp);
+	}
+}
+

Copied: trunk/OpenMPT/soundlib/ModSequence.h (from rev 349, trunk/OpenMPT/soundlib/OrderToPatternTable.h)
===================================================================
--- trunk/OpenMPT/soundlib/ModSequence.h	                        (rev 0)
+++ trunk/OpenMPT/soundlib/ModSequence.h	2009-09-01 18:50:33 UTC (rev 351)
@@ -0,0 +1,68 @@
+#ifndef ORDERTOPATTERNTABLE_H
+#define ORDERTOPATTERNTABLE_H
+
+#include <vector>
+using std::vector;
+
+class CSoundFile;
+
+
+#pragma warning(disable:4244) //conversion from 'type1' to 'type2', possible loss of data.
+
+
+//==============================================
+class COrderToPatternTable : public vector<PATTERNINDEX>
+//==============================================
+{
+public:
+	COrderToPatternTable(const CSoundFile& sndFile) : m_rSndFile(sndFile) {}
+
+	// Initialize default sized sequence.
+	void Init();
+
+	bool ReadAsByte(const BYTE* pFrom, const int howMany, const int memLength);
+
+	size_t WriteAsByte(FILE* f, const UINT count);
+
+	size_t WriteToByteArray(BYTE* dest, const UINT numOfBytes, const UINT destSize);
+
+	ORDERINDEX GetCount() const {return size();}
+
+	//Deprecated function used for MPTm's created in 1.17.02.46 - 1.17.02.48.
+	DWORD Deserialize(const BYTE* const src, const DWORD memLength);
+	
+	//Returns true if the IT orderlist datafield is not sufficient to store orderlist information.
+	bool NeedsExtraDatafield() const;
+
+	void OnModTypeChanged(const MODTYPE oldtype);
+
+	// Returns length of sequence without counting trailing '---' items.
+	ORDERINDEX GetLengthTailTrimmed() const;
+
+	// Returns length of sequence stopping counting on first '---' (or at the end of sequence).
+	ORDERINDEX GetLengthFirstEmpty() const;
+
+	PATTERNINDEX GetInvalidPatIndex() const; //To correspond 0xFF
+	static PATTERNINDEX GetInvalidPatIndex(const MODTYPE type);
+
+	PATTERNINDEX GetIgnoreIndex() const; //To correspond 0xFE
+	static PATTERNINDEX GetIgnoreIndex(const MODTYPE type);
+
+	//Returns the previous/next order ignoring skip indeces(+++).
+	//If no previous/next order exists, return first/last order, and zero
+	//when orderlist is empty.
+	ORDERINDEX GetNextOrderIgnoringSkips(const ORDERINDEX start) const;
+	ORDERINDEX GetPreviousOrderIgnoringSkips(const ORDERINDEX start) const;
+
+private:
+	const CSoundFile& m_rSndFile;
+};
+
+#pragma warning(default:4244) //conversion from 'type1' to 'type2', possible loss of data.
+
+
+void ReadModSequence(std::istream& iStrm, COrderToPatternTable& seq, const size_t nSize = 0);
+void WriteModSequence(std::ostream& oStrm, const COrderToPatternTable& seq);
+
+#endif
+

Deleted: trunk/OpenMPT/soundlib/OrderToPatternTable.cpp
===================================================================
--- trunk/OpenMPT/soundlib/OrderToPatternTable.cpp	2009-08-30 22:27:15 UTC (rev 350)
+++ trunk/OpenMPT/soundlib/OrderToPatternTable.cpp	2009-09-01 18:50:33 UTC (rev 351)
@@ -1,221 +0,0 @@
-#include "stdafx.h"
-#include "sndfile.h"
-#include "ordertopatterntable.h"
-#include "../mptrack/serialization_utils.h"
-
-#define str_SequenceTruncationNote (GetStrI18N((_TEXT("Module has sequence of length %u; it will be truncated to maximum supported length, %u."))))
-
-DWORD COrderToPatternTable::Deserialize(const BYTE* const src, const DWORD memLength)
-//-------------------------------------------------------------------------
-{
-	if(memLength < 2 + 4) return 0;
-	uint16 version = 0;
-	uint32 s = 0;
-	DWORD memPos = 0;
-	memcpy(&version, src, sizeof(version));
-	memPos += sizeof(version);
-	if(version != 0) return memPos;
-    memcpy(&s, src+memPos, sizeof(s));
-	memPos += sizeof(s);
-	if(s > 65000) return true;
-	if(memLength < memPos+s*4) return memPos;
-
-	const uint32 nOriginalSize = s;
-	if(s > ModSpecs::mptm.ordersMax)
-		s = ModSpecs::mptm.ordersMax;
-
-	resize(max(s, MAX_ORDERS));
-	for(size_t i = 0; i<s; i++, memPos +=4 )
-	{
-		uint32 temp;
-		memcpy(&temp, src+memPos, 4);
-		(*this)[i] = static_cast<PATTERNINDEX>(temp);
-	}
-	memPos += 4*(nOriginalSize - s);
-	return memPos;
-}
-
-
-size_t COrderToPatternTable::WriteToByteArray(BYTE* dest, const UINT numOfBytes, const UINT destSize)
-//-----------------------------------------------------------------------------
-{
-	if(numOfBytes > destSize) return true;
-	if(size() < numOfBytes) resize(numOfBytes, 0xFF);
-	UINT i = 0;
-	for(i = 0; i<numOfBytes; i++)
-	{
-		dest[i] = static_cast<BYTE>((*this)[i]);
-	}
-	return i; //Returns the number of bytes written.
-}
-
-
-size_t COrderToPatternTable::WriteAsByte(FILE* f, const UINT count)
-//---------------------------------------------------------------
-{
-	if(size() < count) resize(count, GetInvalidPatIndex());
-
-	size_t i = 0;
-	
-	for(i = 0; i<count; i++)
-	{
-		const PATTERNINDEX pat = (*this)[i];
-		BYTE temp = static_cast<BYTE>((*this)[i]);
-
-		if(pat > 0xFD)
-		{
-			if(pat == GetInvalidPatIndex()) temp = 0xFF;
-			else temp = 0xFE;
-		}
-		fwrite(&temp, 1, 1, f);
-	}
-	return i; //Returns the number of bytes written.
-}
-
-bool COrderToPatternTable::ReadAsByte(const BYTE* pFrom, const int howMany, const int memLength)
-//-------------------------------------------------------------------------
-{
-	if(howMany < 0 || howMany > memLength) return true;
-	if(m_rSndFile.GetType() != MOD_TYPE_MPT && howMany > MAX_ORDERS) return true;
-	
-	if(size() < static_cast<size_t>(howMany))
-		resize(howMany, GetInvalidPatIndex());
-	
-	for(int i = 0; i<howMany; i++, pFrom++)
-		(*this)[i] = *pFrom;
-	return false;
-}
-
-
-bool COrderToPatternTable::NeedsExtraDatafield() const
-//----------------------------------------------
-{
-	if(m_rSndFile.GetType() == MOD_TYPE_MPT && m_rSndFile.Patterns.Size() > 0xFD)
-		return true;
-	else
-		return false;
-}
-
-
-void COrderToPatternTable::OnModTypeChanged(const MODTYPE oldtype)
-//----------------------------------------------------------------
-{
-	const CModSpecifications specs = m_rSndFile.GetModSpecifications();
-
-	//Resize orderlist if needed. Because old orderlist had MAX_ORDERS(256) elements, not making it
-	//smaller than that even if the modtype doesn't support that many orders.
-	if(specs.ordersMax < GetCount()) 
-	{
-		resize(max(MAX_ORDERS, specs.ordersMax));
-		for(ORDERINDEX i = GetCount(); i>specs.ordersMax; --i) (*this)[i-1] = GetInvalidPatIndex();
-	}
-	if (GetCount() < MAX_ORDERS)
-		resize(MAX_ORDERS, GetInvalidPatIndex());
-
-	//Replace items used to denote end of song/skip order.
-	replace(begin(), end(), GetInvalidPatIndex(oldtype), GetInvalidPatIndex());
-	replace(begin(), end(), GetIgnoreIndex(oldtype), GetIgnoreIndex());
-}
-
-
-ORDERINDEX COrderToPatternTable::GetLengthTailTrimmed() const
-//-----------------------------------------------------------
-{
-	ORDERINDEX nEnd = GetCount();
-	if(nEnd == 0) return 0;
-	nEnd--;
-	const PATTERNINDEX iInvalid = GetInvalidPatIndex();
-	while(nEnd > 0 && (*this)[nEnd] == iInvalid)
-		nEnd--;
-	return ((*this)[nEnd] == iInvalid) ? 0 : nEnd+1;
-}
-
-
-ORDERINDEX COrderToPatternTable::GetLengthFirstEmpty() const
-//----------------------------------------------------------
-{
-	const ORDERINDEX nLength = GetCount();
-	ORDERINDEX nMax = 0;
-	while ((nMax < nLength) && ((*this)[nMax] != (*this).GetInvalidPatIndex())) nMax++;
-	return nMax;
-}
-
-
-ORDERINDEX COrderToPatternTable::GetNextOrderIgnoringSkips(const ORDERINDEX start) const
-//-------------------------------------------------------------------------------------
-{
-	const ORDERINDEX count = GetCount();
-	if(count == 0) return 0;
-	ORDERINDEX next = min(count-1, start+1);
-	while(next+1 < count && (*this)[next] == GetIgnoreIndex()) next++;
-	return next;
-}
-
-ORDERINDEX COrderToPatternTable::GetPreviousOrderIgnoringSkips(const ORDERINDEX start) const
-//-------------------------------------------------------------------------------------
-{
-	const ORDERINDEX count = GetCount();
-	if(start == 0 || count == 0) return 0;
-	ORDERINDEX prev = min(start-1, count-1);
-	while(prev > 0 && (*this)[prev] == GetIgnoreIndex()) prev--;
-	return prev;
-}
-
-
-void COrderToPatternTable::Init()
-//-------------------------------
-{
-	resize(MAX_ORDERS, GetInvalidPatIndex());
-	for(ORDERINDEX i = 0; i < GetCount(); i++)
-	{
-		(*this)[i] = GetInvalidPatIndex();
-	}
-}
-
-
-
-PATTERNINDEX COrderToPatternTable::GetInvalidPatIndex(const MODTYPE type) {return type == MOD_TYPE_MPT ?  65535 : 0xFF;}
-PATTERNINDEX COrderToPatternTable::GetIgnoreIndex(const MODTYPE type) {return type == MOD_TYPE_MPT ? 65534 : 0xFE;}
-
-PATTERNINDEX COrderToPatternTable::GetInvalidPatIndex() const {return GetInvalidPatIndex(m_rSndFile.GetType());}
-PATTERNINDEX COrderToPatternTable::GetIgnoreIndex() const {return GetIgnoreIndex(m_rSndFile.GetType());}
-
-
-void ReadModSequence(std::istream& iStrm, COrderToPatternTable& seq, const size_t)
-//--------------------------------------------------------------------------------
-{
-	uint16 size;
-	srlztn::Binaryread<uint16>(iStrm, size);
-	if(size > ModSpecs::mptm.ordersMax)
-	{
-		// Hack: Show message here if trying to load longer sequence than what is supported.
-		CString str; str.Format(str_SequenceTruncationNote, size, ModSpecs::mptm.ordersMax);
-		AfxMessageBox(str, MB_ICONWARNING);
-		size = ModSpecs::mptm.ordersMax;
-	}
-	seq.resize(max(size, MAX_ORDERS), seq.GetInvalidPatIndex());
-	if(size == 0)
-		{ seq.Init(); return; }
-
-	for(size_t i = 0; i < size; i++)
-	{
-		uint16 temp;
-		srlztn::Binaryread<uint16>(iStrm, temp);
-		seq[i] = temp;
-	}
-}
-
-
-void WriteModSequence(std::ostream& oStrm, const COrderToPatternTable& seq)
-//-------------------------------------------------------------------------
-{
-	uint16 size = seq.GetCount();
-	srlztn::Binarywrite<uint16>(oStrm, size);
-	const COrderToPatternTable::const_iterator endIter = seq.end();
-	for(COrderToPatternTable::const_iterator citer = seq.begin(); citer != endIter; citer++)
-	{
-		const uint16 temp = static_cast<uint16>(*citer);
-		srlztn::Binarywrite<uint16>(oStrm, temp);
-	}
-}
-

Deleted: trunk/OpenMPT/soundlib/OrderToPatternTable.h
===================================================================
--- trunk/OpenMPT/soundlib/OrderToPatternTable.h	2009-08-30 22:27:15 UTC (rev 350)
+++ trunk/OpenMPT/soundlib/OrderToPatternTable.h	2009-09-01 18:50:33 UTC (rev 351)
@@ -1,68 +0,0 @@
-#ifndef ORDERTOPATTERNTABLE_H
-#define ORDERTOPATTERNTABLE_H
-
-#include <vector>
-using std::vector;
-
-class CSoundFile;
-
-
-#pragma warning(disable:4244) //conversion from 'type1' to 'type2', possible loss of data.
-
-
-//==============================================
-class COrderToPatternTable : public vector<PATTERNINDEX>
-//==============================================
-{
-public:
-	COrderToPatternTable(const CSoundFile& sndFile) : m_rSndFile(sndFile) {}
-
-	// Initialize default sized sequence.
-	void Init();
-
-	bool ReadAsByte(const BYTE* pFrom, const int howMany, const int memLength);
-
-	size_t WriteAsByte(FILE* f, const UINT count);
-
-	size_t WriteToByteArray(BYTE* dest, const UINT numOfBytes, const UINT destSize);
-
-	ORDERINDEX GetCount() const {return size();}
-
-	//Deprecated function used for MPTm's created in 1.17.02.46 - 1.17.02.48.
-	DWORD Deserialize(const BYTE* const src, const DWORD memLength);
-	
-	//Returns true if the IT orderlist datafield is not sufficient to store orderlist information.
-	bool NeedsExtraDatafield() const;
-
-	void OnModTypeChanged(const MODTYPE oldtype);
-
-	// Returns length of sequence without counting trailing '---' items.
-	ORDERINDEX GetLengthTailTrimmed() const;
-
-	// Returns length of sequence stopping counting on first '---' (or at the end of sequence).
-	ORDERINDEX GetLengthFirstEmpty() const;
-
-	PATTERNINDEX GetInvalidPatIndex() const; //To correspond 0xFF
-	static PATTERNINDEX GetInvalidPatIndex(const MODTYPE type);
-
-	PATTERNINDEX GetIgnoreIndex() const; //To correspond 0xFE
-	static PATTERNINDEX GetIgnoreIndex(const MODTYPE type);
-
-	//Returns the previous/next order ignoring skip indeces(+++).
-	//If no previous/next order exists, return first/last order, and zero
-	//when orderlist is empty.
-	ORDERINDEX GetNextOrderIgnoringSkips(const ORDERINDEX start) const;
-	ORDERINDEX GetPreviousOrderIgnoringSkips(const ORDERINDEX start) const;
-
-private:
-	const CSoundFile& m_rSndFile;
-};
-
-#pragma warning(default:4244) //conversion from 'type1' to 'type2', possible loss of data.
-
-
-void ReadModSequence(std::istream& iStrm, COrderToPatternTable& seq, const size_t nSize = 0);
-void WriteModSequence(std::ostream& oStrm, const COrderToPatternTable& seq);
-
-#endif
-

Added: trunk/OpenMPT/soundlib/Snd_defs.h
===================================================================
--- trunk/OpenMPT/soundlib/Snd_defs.h	                        (rev 0)
+++ trunk/OpenMPT/soundlib/Snd_defs.h	2009-09-01 18:50:33 UTC (rev 351)
@@ -0,0 +1,367 @@
+/*
+ * OpenMPT
+ *
+ * Snd_defs.h
+ *
+ * Authors: Olivier Lapicque <oli...@jp...>
+ *          OpenMPT devs
+*/
+
+#ifndef SND_DEF_H
+#define SND_DEF_H
+
+#ifndef LPCBYTE
+typedef const BYTE * LPCBYTE;
+#endif
+
+typedef uint32 ROWINDEX;
+	const ROWINDEX ROWINDEX_MAX = uint32_max;
+typedef uint16 CHANNELINDEX;
+	const CHANNELINDEX CHANNELINDEX_MAX	= uint16_max;
+	const CHANNELINDEX CHANNELINDEX_INVALID	= CHANNELINDEX_MAX;
+typedef uint16 ORDERINDEX;
+	const ORDERINDEX ORDERINDEX_MAX	= uint16_max;
+	const ORDERINDEX ORDERINDEX_INVALID	= ORDERINDEX_MAX;
+typedef uint16 PATTERNINDEX;
+	const PATTERNINDEX PATTERNINDEX_MAX	= uint16_max;
+	const PATTERNINDEX PATTERNINDEX_INVALID	= PATTERNINDEX_MAX;
+typedef uint8  PLUGINDEX;
+typedef uint16 TEMPO;
+typedef uint16 SAMPLEINDEX;
+	const SAMPLEINDEX SAMPLEINDEX_MAX	= uint16_max;
+	const SAMPLEINDEX SAMPLEINDEX_INVALID	= SAMPLEINDEX_MAX;
+typedef uint16 INSTRUMENTINDEX;
+	const SAMPLEINDEX INSTRUMENTINDEX_MAX	= uint16_max;
+	const SAMPLEINDEX INSTRUMENTINDEX_INVALID	= INSTRUMENTINDEX_MAX;
+typedef uint8 SEQUENCEINDEX;
+	const SEQUENCEINDEX SEQUENCEINDEX_MAX	= uint8_max;
+	const SEQUENCEINDEX SEQUENCEINDEX_INVALID	= SEQUENCEINDEX_MAX;
+typedef uint32 MODTYPE;
+
+#define MAX_PATTERN_ROWS	1024	// -> CODE#0008 -> DESC="#define to set pattern size" -! BEHAVIOUR_CHANGE#0008
+
+
+#define MOD_AMIGAC2			0x1AB
+// -> CODE#0006 
+// -> DESC="misc quantity changes"
+#define MAX_SAMPLE_LENGTH	0x10000000	// 0x04000000 (64MB -> now 256MB).
+                                        // Note: Sample size in bytes can be more than 256 MB.
+// -! BEHAVIOUR_CHANGE#0006
+#define MAX_SAMPLE_RATE		100000
+#define MAX_ORDERS			256
+const SEQUENCEINDEX MAX_SEQUENCES = 10;
+#define MAX_PATTERNS		240
+#define MAX_SAMPLES			4000
+
+#define MAX_INSTRUMENTS		256	//200 // -> CODE#0006 -> DESC="misc quantity changes" // -! BEHAVIOUR_CHANGE#0006
+//#ifdef FASTSOUNDLIB
+//#define MAX_CHANNELS		80
+//#else
+// -> CODE#0006
+// -> DESC="misc quantity changes"
+#define MAX_CHANNELS		256	//200 // Note: This is the maximum number of sound channels,
+                                //            see MAX_BASECHANNELS for max pattern channels.
+// -! BEHAVIOUR_CHANGE#0006
+//#endif
+// -> CODE#0006
+// -> DESC="misc quantity changes"
+//#ifdef FASTSOUNDLIB
+//#define MAX_BASECHANNELS	64
+//#else
+#define MAX_BASECHANNELS	127	// Max pattern channels.
+//#endif
+// -! BEHAVIOUR_CHANGE#0006
+#define MAX_ENVPOINTS		32
+#define MIN_PERIOD			0x0020
+#define MAX_PERIOD			0xFFFF
+#define MAX_PATTERNNAME		32
+#define MAX_CHANNELNAME		20
+#define MAX_INFONAME		80
+#define MAX_EQ_BANDS		6
+
+#define MAX_MIXPLUGINS		100	//50 // -> CODE#0006 -> DESC="misc quantity changes" -! BEHAVIOUR_CHANGE#0006
+#define MAX_PLUGPRESETS		1000 //rewbs.plugPresets
+
+#define MOD_TYPE_NONE		0x00
+#define MOD_TYPE_MOD		0x01
+#define MOD_TYPE_S3M		0x02
+#define MOD_TYPE_XM			0x04
+#define MOD_TYPE_MED		0x08
+#define MOD_TYPE_MTM		0x10
+#define MOD_TYPE_IT			0x20
+#define MOD_TYPE_669		0x40
+#define MOD_TYPE_ULT		0x80
+#define MOD_TYPE_STM		0x100
+#define MOD_TYPE_FAR		0x200
+#define MOD_TYPE_WAV		0x400
+#define MOD_TYPE_AMF		0x800
+#define MOD_TYPE_AMS		0x1000
+#define MOD_TYPE_DSM		0x2000
+#define MOD_TYPE_MDL		0x4000
+#define MOD_TYPE_OKT		0x8000
+#define MOD_TYPE_MID		0x10000
+#define MOD_TYPE_DMF		0x20000
+#define MOD_TYPE_PTM		0x40000
+#define MOD_TYPE_DBM		0x80000
+#define MOD_TYPE_MT2		0x100000
+#define MOD_TYPE_AMF0		0x200000
+#define MOD_TYPE_PSM		0x400000
+#define MOD_TYPE_J2B		0x800000
+#define MOD_TYPE_MPT		0x1000000
+#define MOD_TYPE_UMX		0x80000000 // Fake type
+#define MAX_MODTYPE			24
+
+// For compatibility mode
+#define TRK_IMPULSETRACKER	MOD_TYPE_IT | MOD_TYPE_MPT
+#define TRK_FASTTRACKER2	MOD_TYPE_XM
+#define TRK_SCREAMTRACKER	MOD_TYPE_S3M
+#define TRK_PROTRACKER		MOD_TYPE_MOD
+#define TRK_ALLTRACKERS		TRK_IMPULSETRACKER | TRK_FASTTRACKER2 | TRK_SCREAMTRACKER | TRK_PROTRACKER
+
+
+
+// Channel flags:
+// Bits 0-7:	Sample Flags
+#define CHN_16BIT			0x01
+#define CHN_LOOP			0x02
+#define CHN_PINGPONGLOOP	0x04
+#define CHN_SUSTAINLOOP		0x08
+#define CHN_PINGPONGSUSTAIN	0x10
+#define CHN_PANNING			0x20
+#define CHN_STEREO			0x40
+#define CHN_PINGPONGFLAG	0x80	//When flag is on, bidiloop is processed backwards?
+// Bits 8-31:	Channel Flags
+#define CHN_MUTE			0x100
+#define CHN_KEYOFF			0x200
+#define CHN_NOTEFADE		0x400
+#define CHN_SURROUND		0x800
+#define CHN_NOIDO			0x1000
+#define CHN_HQSRC			0x2000
+#define CHN_FILTER			0x4000
+#define CHN_VOLUMERAMP		0x8000
+#define CHN_VIBRATO			0x10000
+#define CHN_TREMOLO			0x20000
+#define CHN_PANBRELLO		0x40000
+#define CHN_PORTAMENTO		0x80000
+#define CHN_GLISSANDO		0x100000
+#define CHN_VOLENV			0x200000
+#define CHN_PANENV			0x400000
+#define CHN_PITCHENV		0x800000
+#define CHN_FASTVOLRAMP		0x1000000
+#define CHN_EXTRALOUD		0x2000000
+#define CHN_REVERB			0x4000000
+#define CHN_NOREVERB		0x8000000
+#define CHN_SOLO			0x10000000 // -> CODE#0012 -> DESC="midi keyboard split" -! NEW_FEATURE#0012
+#define CHN_NOFX			0x20000000 // -> CODE#0015 -> DESC="channels management dlg" -! NEW_FEATURE#0015
+#define CHN_SYNCMUTE		0x40000000
+
+#define ENV_VOLUME			0x0001
+#define ENV_VOLSUSTAIN		0x0002
+#define ENV_VOLLOOP			0x0004
+#define ENV_PANNING			0x0008
+#define ENV_PANSUSTAIN		0x0010
+#define ENV_PANLOOP			0x0020
+#define ENV_PITCH			0x0040
+#define ENV_PITCHSUSTAIN	0x0080
+#define ENV_PITCHLOOP		0x0100
+#define ENV_SETPANNING		0x0200
+#define ENV_FILTER			0x0400
+#define ENV_VOLCARRY		0x0800
+#define ENV_PANCARRY		0x1000
+#define ENV_PITCHCARRY		0x2000
+#define ENV_MUTE			0x4000
+
+
+// Filter Modes
+#define FLTMODE_UNCHANGED		0xFF
+#define FLTMODE_LOWPASS			0
+#define FLTMODE_HIGHPASS		1
+#define FLTMODE_BANDPASS		2
+
+
+#define RSF_16BIT		0x04
+#define RSF_STEREO		0x08
+
+#define RS_PCM8S		0	// 8-bit signed
+#define RS_PCM8U		1	// 8-bit unsigned
+#define RS_PCM8D		2	// 8-bit delta values
+#define RS_ADPCM4		3	// 4-bit ADPCM-packed
+#define RS_PCM16D		4	// 16-bit delta values
+#define RS_PCM16S		5	// 16-bit signed
+#define RS_PCM16U		6	// 16-bit unsigned
+#define RS_PCM16M		7	// 16-bit motorola order
+#define RS_STPCM8S		(RS_PCM8S|RSF_STEREO)	// stereo 8-bit signed
+#define RS_STPCM8U		(RS_PCM8U|RSF_STEREO)	// stereo 8-bit unsigned
+#define RS_STPCM8D		(RS_PCM8D|RSF_STEREO)	// stereo 8-bit delta values
+#define RS_STPCM16S		(RS_PCM16S|RSF_STEREO)	// stereo 16-bit signed
+#define RS_STPCM16U		(RS_PCM16U|RSF_STEREO)	// stereo 16-bit unsigned
+#define RS_STPCM16D		(RS_PCM16D|RSF_STEREO)	// stereo 16-bit delta values
+#define RS_STPCM16M		(RS_PCM16M|RSF_STEREO)	// stereo 16-bit signed big endian
+// IT 2.14 compressed samples
+#define RS_IT2148		0x10
+#define RS_IT21416		0x14
+#define RS_IT2158		0x12
+#define RS_IT21516		0x16
+// AMS Packed Samples
+#define RS_AMS8			0x11
+#define RS_AMS16		0x15
+// DMF Huffman compression
+#define RS_DMF8			0x13
+#define RS_DMF16		0x17
+// MDL Huffman compression
+#define RS_MDL8			0x20
+#define RS_MDL16		0x24
+#define RS_PTM8DTO16	0x25
+// Stereo Interleaved Samples
+#define RS_STIPCM8S		(RS_PCM8S|0x40|RSF_STEREO)	// stereo 8-bit signed
+#define RS_STIPCM8U		(RS_PCM8U|0x40|RSF_STEREO)	// stereo 8-bit unsigned
+#define RS_STIPCM16S	(RS_PCM16S|0x40|RSF_STEREO)	// stereo 16-bit signed
+#define RS_STIPCM16U	(RS_PCM16U|0x40|RSF_STEREO)	// stereo 16-bit unsigned
+#define RS_STIPCM16M	(RS_PCM16M|0x40|RSF_STEREO)	// stereo 16-bit signed big endian
+// 24-bit signed
+#define RS_PCM24S		(RS_PCM16S|0x80)			// mono 24-bit signed
+#define RS_STIPCM24S	(RS_PCM16S|0x80|RSF_STEREO)	// stereo 24-bit signed
+// 32-bit
+#define RS_PCM32S		(RS_PCM16S|0xC0)			// mono 32-bit signed
+#define RS_STIPCM32S	(RS_PCM16S|0xC0|RSF_STEREO)	// stereo 32-bit signed
+
+
+
+// NNA types (New Note Action)
+#define NNA_NOTECUT		0
+#define NNA_CONTINUE	1
+#define NNA_NOTEOFF		2
+#define NNA_NOTEFADE	3
+
+// DCT types (Duplicate Check Types)
+#define DCT_NONE		0
+#define DCT_NOTE		1
+#define DCT_SAMPLE		2
+#define DCT_INSTRUMENT	3
+#define DCT_PLUGIN		4 //rewbs.VSTiNNA
+
+// DNA types (Duplicate Note Action)
+#define DNA_NOTECUT		0
+#define DNA_NOTEOFF		1
+#define DNA_NOTEFADE	2
+
+// Mixer Hardware-Dependent features
+#define SYSMIX_ENABLEMMX	0x01
+#define SYSMIX_SLOWCPU		0x02
+#define SYSMIX_FASTCPU		0x04
+#define SYSMIX_MMXEX		0x08
+#define SYSMIX_3DNOW		0x10
+#define SYSMIX_SSE			0x20
+
+// Module flags
+#define SONG_EMBEDMIDICFG	0x0001
+#define SONG_FASTVOLSLIDES	0x0002
+#define SONG_ITOLDEFFECTS	0x0004
+#define SONG_ITCOMPATMODE	0x0008
+#define SONG_LINEARSLIDES	0x0010
+#define SONG_PATTERNLOOP	0x0020
+#define SONG_STEP			0x0040
+#define SONG_PAUSED			0x0080
+#define SONG_FADINGSONG		0x0100
+#define SONG_ENDREACHED		0x0200
+#define SONG_GLOBALFADE		0x0400
+#define SONG_CPUVERYHIGH	0x0800
+#define SONG_FIRSTTICK		0x1000
+#define SONG_MPTFILTERMODE	0x2000
+#define SONG_SURROUNDPAN	0x4000
+#define SONG_EXFILTERRANGE	0x8000
+#define SONG_AMIGALIMITS	0x10000
+// -> CODE#0023
+// -> DESC="IT project files (.itp)"
+#define SONG_ITPROJECT		0x20000
+#define SONG_ITPEMBEDIH		0x40000
+// -! NEW_FEATURE#0023
+#define SONG_BREAKTOROW		0x80000
+#define SONG_POSJUMP		0x100000
+
+// Global Options (Renderer)
+#define SNDMIX_REVERSESTEREO	0x0001
+#define SNDMIX_NOISEREDUCTION	0x0002
+#define SNDMIX_AGC				0x0004
+#define SNDMIX_NORESAMPLING		0x0008
+//      SNDMIX_NOLINEARSRCMODE is the default
+//#define SNDMIX_HQRESAMPLER		0x0010	 //rewbs.resamplerConf: renamed SNDMIX_HQRESAMPLER to SNDMIX_SPLINESRCMODE
+#define SNDMIX_SPLINESRCMODE	0x0010
+#define SNDMIX_MEGABASS			0x0020
+#define SNDMIX_SURROUND			0x0040
+#define SNDMIX_REVERB			0x0080
+#define SNDMIX_EQ				0x0100
+#define SNDMIX_SOFTPANNING		0x0200
+//#define SNDMIX_ULTRAHQSRCMODE	0x0400 	 //rewbs.resamplerConf: renamed SNDMIX_ULTRAHQSRCMODE to SNDMIX_POLYPHASESRCMODE
+#define SNDMIX_POLYPHASESRCMODE	0x0400
+#define SNDMIX_FIRFILTERSRCMODE	0x0800   //rewbs: added SNDMIX_FIRFILTERSRCMODE
+
+//rewbs.resamplerConf: for stuff that applies to cubic spline, polyphase and FIR
+#define SNDMIX_HQRESAMPLER (SNDMIX_SPLINESRCMODE|SNDMIX_POLYPHASESRCMODE|SNDMIX_FIRFILTERSRCMODE)
+
+////rewbs.resamplerConf: for stuff that applies to polyphase and FIR
+#define SNDMIX_ULTRAHQSRCMODE (SNDMIX_POLYPHASESRCMODE|SNDMIX_FIRFILTERSRCMODE)
+
+// Misc Flags (can safely be turned on or off)
+#define SNDMIX_DIRECTTODISK		0x10000
+#define SNDMIX_ENABLEMMX		0x20000
+#define SNDMIX_NOBACKWARDJUMPS	0x40000
+#define SNDMIX_MAXDEFAULTPAN	0x80000	 // Used by the MOD loader
+#define SNDMIX_MUTECHNMODE		0x100000 // Notes are not played on muted channels
+#define SNDMIX_EMULATE_MIX_BUGS 0x200000 // rewbs.emulateMixBugs
+
+#define MAX_GLOBAL_VOLUME 256
+
+// Resampling modes
+enum {
+	SRCMODE_NEAREST,
+	SRCMODE_LINEAR,
+	SRCMODE_SPLINE,
+	SRCMODE_POLYPHASE,
+	SRCMODE_FIRFILTER, //rewbs.resamplerConf
+	SRCMODE_DEFAULT,
+	NUM_SRC_MODES
+};
+
+enum {
+	ENV_RESET_ALL,
+	ENV_RESET_VOL,
+	ENV_RESET_PAN,
+	ENV_RESET_PITCH,
+	ENV_RELEASE_NODE_UNSET=0xFF,
+	NOT_YET_RELEASED=-1
+};
+
+enum {
+	CHANNEL_ONLY		  = 0,
+	INSTRUMENT_ONLY       = 1,
+	PRIORITISE_INSTRUMENT = 2,
+	PRIORITISE_CHANNEL    = 3,
+	EVEN_IF_MUTED         = false,
+	RESPECT_MUTES         = true,
+};
+
+//Plugin velocity handling options
+enum PLUGVELOCITYHANDLING
+{
+	PLUGIN_VELOCITYHANDLING_CHANNEL = 0,
+	PLUGIN_VELOCITYHANDLING_VOLUME
+};
+
+//Plugin volumecommand handling options
+enum PLUGVOLUMEHANDLING
+{
+	PLUGIN_VOLUMEHANDLING_MIDI = 0,
+	PLUGIN_VOLUMEHANDLING_DRYWET,
+	PLUGIN_VOLUMEHANDLING_IGNORE,
+};
+
+// filtermodes
+/*enum {
+	INST_FILTERMODE_DEFAULT=0,
+	INST_FILTERMODE_HIGHPASS,
+	INST_FILTERMODE_LOWPASS,
+	INST_NUMFILTERMODES
+};*/
+
+#endif

Modified: trunk/OpenMPT/soundlib/Sndfile.h
===================================================================
--- trunk/OpenMPT/soundlib/Sndfile.h	2009-08-30 22:27:15 UTC (rev 350)
+++ trunk/OpenMPT/soundlib/Sndfile.h	2009-09-01 18:50:33 UTC (rev 351)
@@ -7,364 +7,21 @@
  *          OpenMPT devs
 */
 
+#ifndef __SNDFILE_H
+#define __SNDFILE_H
+
 #include "../mptrack/SoundFilePlayConfig.h"
 #include "../mptrack/misc_util.h"
 #include "mod_specifications.h"
 #include <vector>
 #include <bitset>
 #include "midi.h"
+#include "Snd_defs.h"
 
 class CTuningBase;
 typedef CTuningBase CTuning;
 
-using std::bitset;
 
-#ifndef __SNDFILE_H
-#define __SNDFILE_H
-
-#ifndef LPCBYTE
-typedef const BYTE * LPCBYTE;
-#endif
-
-// -> CODE#0008
-// -> DESC="#define to set pattern size"
-#define MAX_PATTERN_ROWS	1024
-// -! BEHAVIOUR_CHANGE#0008
-
-#define MOD_AMIGAC2			0x1AB
-// -> CODE#0006
-// -> DESC="misc quantity changes"
-#define MAX_SAMPLE_LENGTH	0x10000000	// 0x04000000 (64MB -> now 256MB).
-                                        // Note: Sample size in bytes can be more than 256 MB.
-// -! BEHAVIOUR_CHANGE#0006
-#define MAX_SAMPLE_RATE		100000
-#define MAX_ORDERS			256
-#define MAX_PATTERNS		240
-#define MAX_SAMPLES			4000
-// -> CODE#0006
-// -> DESC="misc quantity changes"
-#define MAX_INSTRUMENTS		256	//200
-// -! BEHAVIOUR_CHANGE#0006
-//#ifdef FASTSOUNDLIB
-//#define MAX_CHANNELS		80
-//#else
-// -> CODE#0006
-// -> DESC="misc quantity changes"
-#define MAX_CHANNELS		256	//200 //Note: This is the maximum number of sound channels,
-                                //            see MAX_BASECHANNELS for max pattern channels.
-// -! BEHAVIOUR_CHANGE#0006
-//#endif
-// -> CODE#0006
-// -> DESC="misc quantity changes"
-//#ifdef FASTSOUNDLIB
-//#define MAX_BASECHANNELS	64
-//#else
-#define MAX_BASECHANNELS	127	//Max pattern channels.
-//#endif
-// -! BEHAVIOUR_CHANGE#0006
-#define MAX_ENVPOINTS		32
-#define MIN_PERIOD			0x0020
-#define MAX_PERIOD			0xFFFF
-#define MAX_PATTERNNAME		32
-#define MAX_CHANNELNAME		20
-#define MAX_INFONAME		80
-#define MAX_EQ_BANDS		6
-// -> CODE#0006
-// -> DESC="misc quantity changes"
-#define MAX_MIXPLUGINS		100	//50
-// -! BEHAVIOUR_CHANGE#0006
-#define MAX_PLUGPRESETS		1000 //rewbs.plugPresets
-
-#define MOD_TYPE_NONE		0x00
-#define MOD_TYPE_MOD		0x01
-#define MOD_TYPE_S3M		0x02
-#define MOD_TYPE_XM			0x04
-#define MOD_TYPE_MED		0x08
-#define MOD_TYPE_MTM		0x10
-#define MOD_TYPE_IT			0x20
-#define MOD_TYPE_669		0x40
-#define MOD_TYPE_ULT		0x80
-#define MOD_TYPE_STM		0x100
-#define MOD_TYPE_FAR		0x200
-#define MOD_TYPE_WAV		0x400
-#define MOD_TYPE_AMF		0x800
-#define MOD_TYPE_AMS		0x1000
-#define MOD_TYPE_DSM		0x2000
-#define MOD_TYPE_MDL		0x4000
-#define MOD_TYPE_OKT		0x8000
-#define MOD_TYPE_MID		0x10000
-#define MOD_TYPE_DMF		0x20000
-#define MOD_TYPE_PTM		0x40000
-#define MOD_TYPE_DBM		0x80000
-#define MOD_TYPE_MT2		0x100000
-#define MOD_TYPE_AMF0		0x200000
-#define MOD_TYPE_PSM		0x400000
-#define MOD_TYPE_J2B		0x800000
-#define MOD_TYPE_MPT		0x1000000
-#define MOD_TYPE_UMX		0x80000000 // Fake type
-#define MAX_MODTYPE			24
-
-// For compatibility mode
-#define TRK_IMPULSETRACKER	MOD_TYPE_IT | MOD_TYPE_MPT
-#define TRK_FASTTRACKER2	MOD_TYPE_XM
-#define TRK_SCREAMTRACKER	MOD_TYPE_S3M
-#define TRK_PROTRACKER		MOD_TYPE_MOD
-#define TRK_ALLTRACKERS		TRK_IMPULSETRACKER | TRK_FASTTRACKER2 | TRK_SCREAMTRACKER | TRK_PROTRACKER
-
-
-
-// Channel flags:
-// Bits 0-7:	Sample Flags
-#define CHN_16BIT			0x01
-#define CHN_LOOP			0x02
-#define CHN_PINGPONGLOOP	0x04
-#define CHN_SUSTAINLOOP		0x08
-#define CHN_PINGPONGSUSTAIN	0x10
-#define CHN_PANNING			0x20
-#define CHN_STEREO			0x40
-#define CHN_PINGPONGFLAG	0x80	//When flag is on, bidiloop is processed backwards?
-// Bits 8-31:	Channel Flags
-#define CHN_MUTE			0x100
-#define CHN_KEYOFF			0x200
-#define CHN_NOTEFADE		0x400
-#define CHN_SURROUND		0x800
-#define CHN_NOIDO			0x1000
-#define CHN_HQSRC			0x2000
-#define CHN_FILTER			0x4000
-#define CHN_VOLUMERAMP		0x8000
-#define CHN_VIBRATO			0x10000
-#define CHN_TREMOLO			0x20000
-#define CHN_PANBRELLO		0x40000
-#define CHN_PORTAMENTO		0x80000
-#define CHN_GLISSANDO		0x100000
-#define CHN_VOLENV			0x200000
-#define CHN_PANENV			0x400000
-#define CHN_PITCHENV		0x800000
-#define CHN_FASTVOLRAMP		0x1000000
-#define CHN_EXTRALOUD		0x2000000
-#define CHN_REVERB			0x4000000
-#define CHN_NOREVERB		0x8000000
-// -> CODE#0012
-// -> DESC="midi keyboard split"
-#define CHN_SOLO			0x10000000
-// -! NEW_FEATURE#0012
-
-// -> CODE#0015
-// -> DESC="channels management dlg"
-#define CHN_NOFX			0x20000000
-// -! NEW_FEATURE#0015
-
-#define CHN_SYNCMUTE		0x40000000
-
-#define ENV_VOLUME			0x0001
-#define ENV_VOLSUSTAIN		0x0002
-#define ENV_VOLLOOP			0x0004
-#define ENV_PANNING			0x0008
-#define ENV_PANSUSTAIN		0x0010
-#define ENV_PANLOOP			0x0020
-#define ENV_PITCH			0x0040
-#define ENV_PITCHSUSTAIN	0x0080
-#define ENV_PITCHLOOP		0x0100
-#define ENV_SETPANNING		0x0200
-#define ENV_FILTER			0x0400
-#define ENV_VOLCARRY		0x0800
-#define ENV_PANCARRY		0x1000
-#define ENV_PITCHCARRY		0x2000
-#define ENV_MUTE			0x4000
-
-
-// Filter Modes
-#define FLTMODE_UNCHANGED		0xFF
-#define FLTMODE_LOWPASS			0
-#define FLTMODE_HIGHPASS		1
-#define FLTMODE_BANDPASS		2
-
-
-#define RSF_16BIT		0x04
-#define RSF_STEREO		0x08
-
-#define RS_PCM8S		0	// 8-bit signed
-#define RS_PCM8U		1	// 8-bit unsigned
-#define RS_PCM8D		2	// 8-bit delta values
-#define RS_ADPCM4		3	// 4-bit ADPCM-packed
-#define RS_PCM16D		4	// 16-bit delta values
-#define RS_PCM16S		5	// 16-bit signed
-#define RS_PCM16U		6	// 16-bit unsigned
-#define RS_PCM16M		7	// 16-bit motorola order
-#define RS_STPCM8S		(RS_PCM8S|RSF_STEREO)	// stereo 8-bit signed
-#define RS_STPCM8U		(RS_PCM8U|RSF_STEREO)	// stereo 8-bit unsigned
-#define RS_STPCM8D		(RS_PCM8D|RSF_STEREO)	// stereo 8-bit delta values
-#define RS_STPCM16S		(RS_PCM16S|RSF_STEREO)	// stereo 16-bit signed
-#define RS_STPCM16U		(RS_PCM16U|RSF_STEREO)	// stereo 16-bit unsigned
-#define RS_STPCM16D		(RS_PCM16D|RSF_STEREO)	// stereo 16-bit delta values
-#define RS_STPCM16M		(RS_PCM16M|RSF_STEREO)	// stereo 16-bit signed big endian
-// IT 2.14 compressed samples
-#define RS_IT2148		0x10
-#define RS_IT21416		0x14
-#define RS_IT2158		0x12
-#define RS_IT21516		0x16
-// AMS Packed Samples
-#define RS_AMS8			0x11
-#define RS_AMS16		0x15
-// DMF Huffman compression
-#define RS_DMF8			0x13
-#define RS_DMF16		0x17
-// MDL Huffman compression
-#define RS_MDL8			0x20
-#define RS_MDL16		0x24
-#define RS_PTM8DTO16	0x25
-// Stereo Interleaved Samples
-#define RS_STIPCM8S		(RS_PCM8S|0x40|RSF_STEREO)	// stereo 8-bit signed
-#define RS_STIPCM8U		(RS_PCM8U|0x40|RSF_STEREO)	// stereo 8-bit unsigned
-#define RS_STIPCM16S	(RS_PCM16S|0x40|RSF_STEREO)	// stereo 16-bit signed
-#define RS_STIPCM16U	(RS_PCM16U|0x40|RSF_STEREO)	// stereo 16-bit unsigned
-#define RS_STIPCM16M	(RS_PCM16M|0x40|RSF_STEREO)	// stereo 16-bit signed big endian
-// 24-bit signed
-#define RS_PCM24S		(RS_PCM16S|0x80)			// mono 24-bit signed
-#define RS_STIPCM24S	(RS_PCM16S|0x80|RSF_STEREO)	// stereo 24-bit signed
-// 32-bit
-#define RS_PCM32S		(RS_PCM16S|0xC0)			// mono 32-bit signed
-#define RS_STIPCM32S	(RS_PCM16S|0xC0|RSF_STEREO)	// stereo 32-bit signed
-
-
-
-// NNA types (New Note Action)
-#define NNA_NOTECUT		0
-#define NNA_CONTINUE	1
-#define NNA_NOTEOFF		2
-#define NNA_NOTEFADE	3
-
-// DCT types (Duplicate Check Types)
-#define DCT_NONE		0
-#define DCT_NOTE		1
-#define DCT_SAMPLE		2
-#define DCT_INSTRUMENT	3
-#define DCT_PLUGIN		4 //rewbs.VSTiNNA
-
-// DNA types (Duplicate Note Action)
-#define DNA_NOTECUT		0
-#define DNA_NOTEOFF		1
-#define DNA_NOTEFADE	2
-
-// Mixer Hardware-Dependent features
-#define SYSMIX_ENABLEMMX	0x01
-#define SYSMIX_SLOWCPU		0x02
-#define SYSMIX_FASTCPU		0x04
-#define SYSMIX_MMXEX		0x08
-#define SYSMIX_3DNOW		0x10
-#define SYSMIX_SSE			0x20
-
-// Module flags
-#define SONG_EMBEDMIDICFG	0x0001
-#define SONG_FASTVOLSLIDES	0x0002
-#define SONG_ITOLDEFFECTS	0x0004
-#define SONG_ITCOMPATMODE	0x0008
-#define SONG_LINEARSLIDES	0x0010
-#define SONG_PATTERNLOOP	0x0020
-#define SONG_STEP			0x0040
-#define SONG_PAUSED			0x0080
-#define SONG_FADINGSONG		0x0100
-#define SONG_ENDREACHED		0x0200
-#define SONG_GLOBALFADE		0x0400
-#define SONG_CPUVERYHIGH	0x0800
-#define SONG_FIRSTTICK		0x1000
-#define SONG_MPTFILTERMODE	0x2000
-#define SONG_SURROUNDPAN	0x4000
-#define SONG_EXFILTERRANGE	0x8000
-#define SONG_AMIGALIMITS	0x10000
-// -> CODE#0023
-// -> DESC="IT project files (.itp)"
-#define SONG_ITPROJECT		0x20000
-#define SONG_ITPEMBEDIH		0x40000
-// -! NEW_FEATURE#0023
-#define SONG_BREAKTOROW		0x80000
-#define SONG_POSJUMP		0x100000
-
-// Global Options (Renderer)
-#define SNDMIX_REVERSESTEREO	0x0001
-#define SNDMIX_NOISEREDUCTION	0x0002
-#define SNDMIX_AGC				0x0004
-#define SNDMIX_NORESAMPLING		0x0008
-//      SNDMIX_NOLINEARSRCMODE is the default
-//#define SNDMIX_HQRESAMPLER		0x0010	 //rewbs.resamplerConf: renamed SNDMIX_HQRESAMPLER to SNDMIX_SPLINESRCMODE
-#define SNDMIX_SPLINESRCMODE	0x0010
-#define SNDMIX_MEGABASS			0x0020
-#define SNDMIX_SURROUND			0x0040
-#define SNDMIX_REVERB			0x0080
-#define SNDMIX_EQ				0x0100
-#define SNDMIX_SOFTPANNING		0x0200
-//#define SNDMIX_ULTRAHQSRCMODE	0x0400 	 //rewbs.resamplerConf: renamed SNDMIX_ULTRAHQSRCMODE to SNDMIX_POLYPHASESRCMODE
-#define SNDMIX_POLYPHASESRCMODE	0x0400
-#define SNDMIX_FIRFILTERSRCMODE	0x0800   //rewbs: added SNDMIX_FIRFILTERSRCMODE
-
-//rewbs.resamplerConf: for stuff that applies to cubic spline, polyphase and FIR
-#define SNDMIX_HQRESAMPLER (SNDMIX_SPLINESRCMODE|SNDMIX_POLYPHASESRCMODE|SNDMIX_FIRFILTERSRCMODE)
-
-////rewbs.resamplerConf: for stuff that applies to polyphase and FIR
-#define SNDMIX_ULTRAHQSRCMODE (SNDMIX_POLYPHASESRCMODE|SNDMIX_FIRFILTERSRCMODE)
-
-// Misc Flags (can safely be turned on or off)
-#define SNDMIX_DIRECTTODISK		0x10000
-#define SNDMIX_ENABLEMMX		0x20000
-#define SNDMIX_NOBACKWARDJUMPS	0x40000
-#define SNDMIX_MAXDEFAULTPAN	0x80000	 // Used by the MOD loader
-#define SNDMIX_MUTECHNMODE		0x100000 // Notes are not played on muted channels
-#define SNDMIX_EMULATE_MIX_BUGS 0x200000 // rewbs.emulateMixBugs
-
-#define MAX_GLOBAL_VOLUME 256
-
-// Resampling modes
-enum {
-	SRCMODE_NEAREST,
-	SRCMODE_LINEAR,
-	SRCMODE_SPLINE,
-	SRCMODE_POLYPHASE,
-	SRCMODE_FIRFILTER, //rewbs.resamplerConf
-	SRCMODE_DEFAULT,
-	NUM_SRC_MODES
-};
-
-enum {
-	ENV_RESET_ALL,
-	ENV_RESET_VOL,
-	ENV_RESET_PAN,
-	ENV_RESET_PITCH,
-	ENV_RELEASE_NODE_UNSET=0xFF,
-	NOT_YET_RELEASED=-1
-};
-
-enum {
-	CHANNEL_ONLY		  = 0,
-	INSTRUMENT_ONLY       = 1,
-	PRIORITISE_INSTRUMENT = 2,
-	PRIORITISE_CHANNEL    = 3,
-	EVEN_IF_MUTED         = false,
-	RESPECT_MUTES         = true,
-};
-
-//Plugin velocity handling options
-enum PLUGVELOCITYHANDLING
-{
-	PLUGIN_VELOCITYHANDLING_CHANNEL = 0,
-	PLUGIN_VELOCITYHANDLING_VOLUME
-};
-
-//Plugin volumecommand handling options
-enum PLUGVOLUMEHANDLING
-{
-	PLUGIN_VOLUMEHANDLING_MIDI = 0,
-	PLUGIN_VOLUMEHANDLING_DRYWET,
-	PLUGIN_VOLUMEHANDLING_IGNORE,
-};
-
-// filtermodes
-/*enum {
-	INST_FILTERMODE_DEFAULT=0,
-	INST_FILTERMODE_HIGHPASS,
-	INST_FILTERMODE_LOWPASS,
-	INST_NUMFILTERMODES
-};*/
-
 // Sample Struct
 struct MODSAMPLE
 {
@@ -774,12 +431,11 @@
 
 #include "pattern.h"
 #include "patternContainer.h"
-#include "ordertopatterntable.h"
+#include "ModSequence.h"
+#include "PlaybackEventer.h"
 
-#include "playbackEventer.h"
 
 
-
 class CSoundFile;
 
 //======================
@@ -1022,10 +678,7 @@
 	bool ReadSTM(LPCBYTE lpStream, DWORD dwMemLength);
 	bool ReadIT(LPCBYTE lpStream, const DWORD dwMemLength);
 	//bool ReadMPT(LPCBYTE lpStream, const DWORD dwMemLength);
-// -> CODE#0023
-// -> DESC="IT project files (.itp)"
-	bool ReadITProject(LPCBYTE lpStream, const DWORD dwMemLength);
-// -! NEW_FEATURE#0023
+	bool ReadITProject(LPCBYTE lpStream, const DWORD dwMemLength); // -> CODE#0023 -> DESC="IT project files (.itp)" -! NEW_FEATURE#0023
 	bool Read669(LPCBYTE lpStream, DWORD dwMemLength);
 	bool ReadUlt(LPCBYTE lpStream, DWORD dwMemLength);
 	bool ReadWav(LPCBYTE lpStream, DWORD dwMemLength);
@@ -1055,10 +708,7 @@
 	bool SaveMod(LPCSTR lpszFileName, UINT nPacking=0, const bool bCompatibilityExport = false);
 	bool SaveIT(LPCSTR lpszFileName, UINT nPacking=0);
 	bool SaveCompatIT(LPCSTR lpszFileName);
-// -> CODE#0023
-// -> DESC="IT project files (.itp)"
-	bool SaveITProject(LPCSTR lpszFileName);
-// -! NEW_FEATURE#0023
+	bool SaveITProject(LPCSTR lpszFileName); // -> CODE#0023 -> DESC="IT project files (.itp)" -! NEW_FEATURE#0023
 	UINT SaveMixPlugins(FILE *f=NULL, BOOL bUpdate=TRUE);
 	void WriteInstrumentPropertyForAllInstruments(__int32 code,  __int16 size, FILE* f, MODINSTRUMENT* instruments[], UINT nInstruments);
 	void SaveExtendedInstrumentProperties(MODINSTRUMENT *instruments[], UINT nInstruments, FILE* f);

Modified: trunk/OpenMPT/soundlib/mod_specifications.h
===================================================================
--- trunk/OpenMPT/soundlib/mod_specifications.h	2009-08-30 22:27:15 UTC (rev 350)
+++ trunk/OpenMPT/soundlib/mod_specifications.h	2009-09-01 18:50:33 UTC (rev 351)
@@ -1,6 +1,7 @@
 #ifndef MOD_SPECIFICATIONS_H
 #define MOD_SPECIFICATIONS_H
 
+#include "Snd_defs.h"
 #include "modcommand.h"						// 
 #include "../mptrack/SoundFilePlayConfig.h" // mixlevel constants.
 

Modified: trunk/OpenMPT/soundlib/pattern.h
===================================================================
--- trunk/OpenMPT/soundlib/pattern.h	2009-08-30 22:27:15 UTC (rev 350)
+++ trunk/OpenMPT/soundlib/pattern.h	2009-09-01 18:50:33 UTC (rev 351)
@@ -3,6 +3,7 @@
 
 #include <vector>
 #include "modcommand.h"
+#include "Snd_defs.h"
 
 using std::vector;
 

Modified: trunk/OpenMPT/soundlib/patternContainer.h
===================================================================
--- trunk/OpenMPT/soundlib/patternContainer.h	2009-08-30 22:27:15 UTC (rev 350)
+++ trunk/OpenMPT/soundlib/patternContainer.h	2009-09-01 18:50:33 UTC (rev 351)
@@ -2,6 +2,7 @@
 #define PATTERNCONTAINER_H
 
 #include "pattern.h"
+#include "Snd_defs.h"
 
 class CSoundFile;
 typedef CPattern MODPATTERN;
@@ -25,7 +26,7 @@
 
 //BEGIN: INTERFACE METHODS
 public:
-	CPatternContainer(CSoundFile& sndFile) : m_rSndFile(sndFile) {m_Patterns.assign(240, MODPATTERN(*this));}
+	CPatternContainer(CSoundFile& sndFile) : m_rSndFile(sndFile) {m_Patterns.assign(MAX_PATTERNS, MODPATTERN(*this));}
 
 	// Clears existing patterns and resizes array to default size.
 	void Init();


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-08-30 22:27:26

Revision: 350
          http://modplug.svn.sourceforge.net/modplug/?rev=350&view=rev
Author:   saga-games
Date:     2009-08-30 22:27:15 +0000 (Sun, 30 Aug 2009)

Log Message:
-----------
[Fix] S3M Loader: Small modifications to pattern loader to load somewhat broken S3M files
[Fix] S3M Loader: Don't reset global volume to max if it is min for "new" modules
[Fix] S3M Loader: Smarter Zxx conversion
[Fix] S3M Saver: Was completely broken for a reason that's beyond my understanding :) (order size only has to be multiple of 2, not 16!)
[Imp] Mod Conversion: Convert 500/600 commands properly from MOD to any format, Adjust sustain loops for XM files, removed XM arpeggio conversion (it might be unwanted)

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/Modedit.cpp
    trunk/OpenMPT/soundlib/Load_s3m.cpp

Modified: trunk/OpenMPT/mptrack/Modedit.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Modedit.cpp	2009-08-30 14:29:58 UTC (rev 349)
+++ trunk/OpenMPT/mptrack/Modedit.cpp	2009-08-30 22:27:15 UTC (rev 350)
@@ -396,15 +396,22 @@
 			} // End if (oldTypeIsIT_MPT && newTypeIsS3M)
 
 
-			////////////////////////
-			// Convert XM arpeggio
-			if(m->command == CMD_ARPEGGIO && (newTypeIsXM || oldTypeIsXM))
+
+			///////////////////////////////////////////////////
+			// Convert MOD to anything - adjust effect memory
+			if (oldTypeIsMOD)
 			{
-				// swap notes
-				m->param = ((m->param & 0x0F) << 4) | ((m->param & 0xF0) >> 4);
-			}
+				switch(m->command)
+				{
+				case CMD_TONEPORTAVOL: // lacks memory -> 500 is the same as 300
+					if(m->param == 0x00) m->command = CMD_TONEPORTAMENTO;
+					break;
+				case CMD_VIBRATOVOL: // lacks memory -> 600 is the same as 400
+					if(m->param == 0x00) m->command = CMD_VIBRATO;
+					break;
+				}
+			} // End if (oldTypeIsMOD && newTypeIsXM)
 
-
 			/////////////////////////////////////////////////////////////////////////////////
 			// Convert anything to MOD - remove volume column, adjust retrig, effect memory
 			if (newTypeIsMOD)
@@ -664,26 +671,38 @@
 			CSoundFile::FrequencyToTranspose(&m_SndFile.Samples[i]);
 			if (!(m_SndFile.Samples[i].uFlags & CHN_PANNING)) m_SndFile.Samples[i].nPan = 128;
 		}
-		BOOL bBrokenNoteMap = FALSE;
-		for (UINT j=1; j<=m_SndFile.m_nInstruments; j++)
+		bool bBrokenNoteMap = false, bBrokenSustainLoop = false;
+		for (UINT j = 1; j <= m_SndFile.m_nInstruments; j++)
 		{
 			MODINSTRUMENT *pIns = m_SndFile.Instruments[j];
 			if (pIns)
 			{
-				for (UINT k=0; k<NOTE_MAX; k++)
+				for (UINT k = 0; k < NOTE_MAX; k++)
 				{
 					if ((pIns->NoteMap[k]) && (pIns->NoteMap[k] != (BYTE)(k+1)))
 					{
-						bBrokenNoteMap = TRUE;
+						bBrokenNoteMap = true;
 						break;
 					}
 				}
+				// Convert sustain loops to sustain "points"
+				if(pIns->VolEnv.nSustainStart != pIns->VolEnv.nSustainEnd)
+				{
+					pIns->VolEnv.nSustainEnd = pIns->VolEnv.nSustainStart;
+					bBrokenSustainLoop = true;
+				}
+				if(pIns->PanEnv.nSustainStart != pIns->PanEnv.nSustainEnd)
+				{
+					pIns->PanEnv.nSustainEnd = pIns->PanEnv.nSustainStart;
+					bBrokenSustainLoop = true;
+				}
 				pIns->dwFlags &= ~(ENV_SETPANNING|ENV_VOLCARRY|ENV_PANCARRY|ENV_PITCHCARRY|ENV_FILTER|ENV_PITCH);
 				pIns->nIFC &= 0x7F;
 				pIns->nIFR &= 0x7F;
 			}
 		}
 		if (bBrokenNoteMap) AddToLog("WARNING: Note Mapping will be lost when saving as XM.\n");
+		if (bBrokenSustainLoop) AddToLog("WARNING: Sustain loops were converted to sustain points.\n");
 	}
 
 	if(newTypeIsMOD)

Modified: trunk/OpenMPT/soundlib/Load_s3m.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_s3m.cpp	2009-08-30 14:29:58 UTC (rev 349)
+++ trunk/OpenMPT/soundlib/Load_s3m.cpp	2009-08-30 22:27:15 UTC (rev 350)
@@ -18,43 +18,6 @@
 
 extern WORD S3MFineTuneTable[16];
 
-static void HandleZxx(uint8& nType, MODCOMMAND* const m)
-//-------------------------------------------------------------------
-{
-	if(nType == 0)
-	{
-		CString str;
-		str.Format(GetStrI18N("The S3M file contains Zxx effect. "
-			"It can be processed in the following ways:\n"
-			"Yes   : Convert Zxx to S8x(set panning)-effects (PixPlay)\n"
-			"No    : Remove Zxx effects\n"
-			"Cancel: Keep Zxx effects\n"
-			"\nNote that options (yes) and (no) modify the loaded pattern data."
-			));
-		const int nResult = ::AfxMessageBox(str, MB_YESNOCANCEL|MB_ICONINFORMATION);
-
-		if(nResult == IDYES)
-			nType = 2;
-		else if(nResult == IDNO)
-			nType = 3;
-		else
-			nType = 1;
-	}
-	if(nType != 1)
-	{
-		if(nType == 2)
-		{
-			m->command = CMD_S3MCMDEX;
-			m->param = 0x80 + (m->param & 0xF);
-		}
-		else
-		{
-			m->command = 0;
-			m->param = 0;
-		}
-	}
-}
-
 //////////////////////////////////////////////////////
 // ScreamTracker S3M file support
 
@@ -264,6 +227,7 @@
 	DWORD dwMemPos;
 	BYTE insflags[128], inspack[128];
 	S3MFILEHEADER psfh = *(S3MFILEHEADER *)lpStream;
+	bool bKeepMidiMacros = false;
 
 	psfh.reserved1 = LittleEndianW(psfh.reserved1);
 	psfh.ordnum = LittleEndianW(psfh.ordnum);
@@ -278,8 +242,26 @@
 	if (psfh.scrm != 0x4D524353) return false;
 
 	if((psfh.cwtv & 0xF000) == 0x5000) // OpenMPT Version number (Major.Minor)
+	{
 		m_dwLastSavedWithVersion = (psfh.cwtv & 0x0FFF) << 16;
+		bKeepMidiMacros = true; // simply load Zxx commands
+	}
+	if(psfh.cwtv  == 0x1320 && psfh.special == 0 && (psfh.ordnum & 0x0F) == 0 && psfh.ultraclicks == 0 && (psfh.flags & ~0x50) == 0)
+	{
+		// MPT 1.16 and older versions of OpenMPT
+		m_dwLastSavedWithVersion = MAKE_VERSION_NUMERIC(1, 16, 00, 00);
+		bKeepMidiMacros = true; // simply load Zxx commands
+	}
 
+	if((psfh.cwtv & 0xF000) >= 0x2000)
+	{
+		// 2xyy - Orpheus, 3xyy - IT, 4xyy - Schism, 5xyy - OpenMPT
+		bKeepMidiMacros = true; // simply load Zxx commands
+	}
+
+	if(!bKeepMidiMacros) // Remove macros so they don't interfere with other tunes
+		memset(&m_MidiCfg, 0, sizeof(m_MidiCfg));
+
 	dwMemPos = 0x60;
 	m_nType = MOD_TYPE_S3M;
 	memset(m_szNames,0,sizeof(m_szNames));
@@ -292,7 +274,8 @@
 	m_nDefaultTempo = CLAMP(m_nDefaultTempo, 32, 255);
 	// Global Volume
 	m_nDefaultGlobalVolume = psfh.globalvol << 2;
-	if ((!m_nDefaultGlobalVolume) || (m_nDefaultGlobalVolume > 256)) m_nDefaultGlobalVolume = 256;
+	if(!m_nDefaultGlobalVolume && psfh.cwtv < 0x1320) m_nDefaultGlobalVolume = 256; // not very reliable, but it fixes a few tunes
+	if(m_nDefaultGlobalVolume > 256) m_nDefaultGlobalVolume = 256;
 	m_nSamplePreAmp = psfh.mastervol & 0x7F; // Bit 8 = Stereo (we always use stereo)
 	// Channels
 	m_nChannels = 4;
@@ -386,8 +369,14 @@
 			//ASSERT(iLooplength == 0 || iLooplength > 4);
 		}
 	}
+
+	/* Try to find out if Zxx commands are supposed to be panning commands (PixPlay).
+	   We won't convert if there are not enough Zxx commands, too "high" Zxx commands
+	   or there are only "left" or "right" pannings (we assume that stereo should be somewhat balanced) */
+	bool bDoNotConvertZxx = false;
+	int iZxxCountRight = 0, iZxxCountLeft = 0;
+
 	// Reading patterns
-	uint8 nZxxHandling = 0;
 	for (UINT iPat=0; iPat<patnum; iPat++)
 	{
 		UINT nInd = ((DWORD)ptr[nins+iPat]) << 4;
@@ -402,8 +391,9 @@
 		MODCOMMAND *p = Patterns[iPat];
 		UINT row = 0;
 		UINT j = 0;
-		while (j < len)
+		while (row < 64) // this fixes ftp://us.aminet.net/pub/aminet/mods/8voic/s3m_hunt.lha (was: while (j < len))
 		{
+			if(j + nInd + 1 >= dwMemLength) break;
 			BYTE b = src[j++];
 			if (!b)
 			{
@@ -416,6 +406,7 @@
 					MODCOMMAND *m = &p[row*m_nChannels+chn];
 					if (b & 0x20)
 					{
+						if(j + nInd + 2 >= dwMemLength) break;
 						m->note = src[j++];
 						if (m->note < 0xF0) m->note = (m->note & 0x0F) + 12*(m->note >> 4) + 13;
 						else if (m->note == 0xFF) m->note = NOTE_NONE;
@@ -423,6 +414,7 @@
 					}
 					if (b & 0x40)
 					{
+						if(j + nInd + 1 >= dwMemLength) break;
 						UINT vol = src[j++];
 						if ((vol >= 128) && (vol <= 192))
 						{
@@ -437,12 +429,22 @@
 					}
 					if (b & 0x80)
 					{
+						if(j + nInd + 2 >= dwMemLength) break;
 						m->command = src[j++];
 						m->param = src[j++];
 						if (m->command) S3MConvert(m, FALSE);
 						if(m->command == CMD_MIDI)
 						{
-							HandleZxx(nZxxHandling, m);
+							if(m->param > 0x0F)
+							{
+								// PixPlay has Z00 to Z0F panning, so we ignore this.
+								bDoNotConvertZxx = true;
+							}
+							else
+							{
+								if(m->param < 0x08) iZxxCountLeft++;
+								if(m->param > 0x08) iZxxCountRight++;
+							}
 						}
 					}
 				} else
@@ -451,10 +453,27 @@
 					if (b & 0x40) j++;
 					if (b & 0x80) j += 2;
 				}
-				if (j >= len) break;
 			}
 		}
 	}
+
+	if((UINT)(iZxxCountLeft + iZxxCountRight) >= m_nChannels && !bDoNotConvertZxx && (iZxxCountLeft - iZxxCountRight > -(int)m_nChannels))
+	{
+		// there are enough Zxx commands, so let's assume this was made to be played with PixPlay
+		for(PATTERNINDEX nPat = 0; nPat < Patterns.Size(); nPat++) if(Patterns[nPat])
+		{
+			MODCOMMAND *m = Patterns[nPat];
+			for(UINT len = PatternSize[nPat] * m_nChannels; len; m++, len--)
+			{
+				if(m->command == CMD_MIDI)
+				{
+					m->command = CMD_S3MCMDEX;
+					m->param |= 0x80;
+				}
+			}
+		}
+	}
+
 	// Reading samples
 	for (UINT iRaw=1; iRaw<=insnum; iRaw++) if ((Samples[iRaw].nLength) && (insfile[iRaw]))
 	{
@@ -469,11 +488,6 @@
 	m_nMaxPeriod = 32767;
 	if (psfh.flags & 0x10) m_dwSongFlags |= SONG_AMIGALIMITS;
 
-	if(nZxxHandling != 0 && nZxxHandling != 1 && GetpModDoc() != 0)
-	{
-		GetpModDoc()->SetModified();
-		GetpModDoc()->SetShowSaveDialog(true);
-	}
 	return true;
 }
 
@@ -507,15 +521,14 @@
 	header[0x1B] = 0;
 	header[0x1C] = 0x1A;
 	header[0x1D] = 0x10;
-	// Changes to 1.17.02.53:
-	//   -Try to save whole sequence instead of stopping on first empty order.
-	//   -With more than 0xF0 orders, limit sequence to 0xF0 instead of just masking with 0xF0.
-	//TODO: Check whether the 0xF0 mask is correct.
-	//		(there are two bytes reserved from the header, so why 0xF0 mask?).
-	//nbo = (GetNumPatterns() + 15) & 0xF0;
+
 	nbo = Order.GetLengthTailTrimmed();
-	if(nbo > 0xF0) nbo = 0xF0;
-	if (!nbo) nbo = 1;
+	if (nbo < 2)
+		nbo = 2;
+	else if (nbo & 1) // number of orders must be even
+		nbo++;
+	nbo = (nbo + 15) & 0xF0; // TODO why does it not work otherwise? nbo should be multiple of 2, not 16!
+	if(nbo > 0xF0) nbo = 0xF0; // sequence too long
 	header[0x20] = nbo & 0xFF;
 	header[0x21] = nbo >> 8;
 	nbi = m_nInstruments;
@@ -536,7 +549,7 @@
 	// Following: One nibble = Major version, one byte = Minor version (hex)
 	MptVersion::VersionNum vVersion = MptVersion::num;
 	header[0x28] = (BYTE)((vVersion >> 16) & 0xFF); // the "17" in OpenMPT 1.17
-	header[0x29] = 0x50 | (BYTE)((vVersion >> 24) & 0x0F); // the "1" in OpenMPT 1.17 + OpenMPT Identifier 5 (works only for versions up to 15.99 :))
+	header[0x29] = 0x50 | (BYTE)((vVersion >> 24) & 0x0F); // the "1." in OpenMPT 1.17 + OpenMPT Identifier 5 (works only for versions up to 9.99 :))
 	header[0x2A] = 0x02; // Version = 1 => Signed samples
 	header[0x2B] = 0x00;
 	header[0x2C] = 'S';
@@ -548,7 +561,7 @@
 	header[0x32] = CLAMP(m_nDefaultTempo, 32, 255);
 	header[0x33] = CLAMP(m_nSamplePreAmp, 0x10, 0x7F) | 0x80;	// Bit 8 = Stereo
 	header[0x34] = 0x10; // 16 Channels for UltraClick removal
-	header[0x35] = 0xFC;
+	header[0x35] = 0xFC; // Write pan positions
 	for (i=0; i<32; i++)
 	{
 		if (i < m_nChannels)
@@ -562,7 +575,7 @@
 	memset(patptr, 0, sizeof(patptr));
 	memset(insptr, 0, sizeof(insptr));
 	UINT ofs0 = 0x60 + nbo;
-	UINT ofs1 = ((0x60 + nbo + nbi*2 + nbp*2 + 15) & 0xFFF0) + 0x20;
+	UINT ofs1 = ((0x60 + nbo + nbi * 2 + nbp * 2 + 15) & 0xFFF0) + ((header[0x35] == 0xFC) ? 0x20 : 0);
 	UINT ofs = ofs1;
 	for (i=0; i<nbi; i++) insptr[i] = (WORD)((ofs + i*0x50) / 16);
 	for (i=0; i<nbp; i++) patptr[i] = (WORD)((ofs + nbi*0x50) / 16);


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-08-30 14:30:04

Revision: 349
          http://modplug.svn.sourceforge.net/modplug/?rev=349&view=rev
Author:   saga-games
Date:     2009-08-30 14:29:58 +0000 (Sun, 30 Aug 2009)

Log Message:
-----------
[Fix] XM Compatibility: Compatible Arpeggio was done wrong
[Fix] XM Compatibility: More compatible "Note Off + Something"
[Fix] IT COmpatibility: Removed a "fix" again that was causing to completely destroy panbrello
[Imp] Comments tab: Only switch only to instrument list in XM modules if there are actually instruments

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/view_com.cpp
    trunk/OpenMPT/soundlib/Snd_fx.cpp
    trunk/OpenMPT/soundlib/Sndmix.cpp

Modified: trunk/OpenMPT/mptrack/view_com.cpp
===================================================================
--- trunk/OpenMPT/mptrack/view_com.cpp	2009-08-30 00:07:19 UTC (rev 348)
+++ trunk/OpenMPT/mptrack/view_com.cpp	2009-08-30 14:29:58 UTC (rev 349)
@@ -114,7 +114,7 @@
 		if(pModDoc)
 		{
 			pSndFile= pModDoc->GetSoundFile();
-			if(pSndFile && (pSndFile->m_nType & MOD_TYPE_XM))
+			if(pSndFile && (pSndFile->m_nType & MOD_TYPE_XM) && pSndFile->m_nInstruments > 0)
 			{
 				m_nListId = IDC_LIST_INSTRUMENTS;
 			}

Modified: trunk/OpenMPT/soundlib/Snd_fx.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Snd_fx.cpp	2009-08-30 00:07:19 UTC (rev 348)
+++ trunk/OpenMPT/soundlib/Snd_fx.cpp	2009-08-30 14:29:58 UTC (rev 349)
@@ -1233,8 +1233,8 @@
 					note = instr = 0;
 				}
 
-				// XM: Key-Off + Sample == Note Cut (BUT: Only if no instr number is present!)
-				if ((note == NOTE_KEYOFF) && (!pChn->pModInstrument || !IsCompatibleMode(TRK_FASTTRACKER2)) && ((!pChn->pModInstrument) || (!(pChn->pModInstrument->dwFlags & ENV_VOLUME))))
+				// XM: Key-Off + Sample == Note Cut (BUT: Only if no instr number or volume effect is present!)
+				if ((note == NOTE_KEYOFF) && ((!instr && !vol && cmd != CMD_VOLUME) || !IsCompatibleMode(TRK_FASTTRACKER2)) && ((!pChn->pModInstrument) || (!(pChn->pModInstrument->dwFlags & ENV_VOLUME))))
 				{
 					pChn->dwFlags |= CHN_FASTVOLRAMP;
 					pChn->nVolume = 0;

Modified: trunk/OpenMPT/soundlib/Sndmix.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Sndmix.cpp	2009-08-30 00:07:19 UTC (rev 348)
+++ trunk/OpenMPT/soundlib/Sndmix.cpp	2009-08-30 14:29:58 UTC (rev 349)
@@ -951,8 +951,7 @@
 			pChn->nRealPan = pChn->nPan;
 		}
 
-		if (pChn->nRealPan < 0) pChn->nRealPan = 0;
-		if (pChn->nRealPan > 256) pChn->nRealPan = 256;
+		pChn->nRealPan = CLAMP(pChn->nRealPan, 0, 256);
 		pChn->nRampLength = 0;
 
 		//Aux variables
@@ -1231,7 +1230,7 @@
 
 						if (!(m_dwSongFlags & SONG_FIRSTTICK))
 						{
-							arpPos = (m_nTickCount - m_nMusicSpeed) % 3;
+							arpPos = ((int)m_nTickCount - (int)m_nMusicSpeed) % 3;
 							if(arpPos < 0) arpPos += 3;
 							switch(arpPos)
 							{
@@ -1445,7 +1444,7 @@
 				pdelta += pChn->nRealPan;
 				
 				pChn->nRealPan = CLAMP(pdelta, 0, 256);
-				if(IsCompatibleMode(TRK_IMPULSETRACKER)) pChn->nPan = pChn->nRealPan;
+				//if(IsCompatibleMode(TRK_IMPULSETRACKER)) pChn->nPan = pChn->nRealPan; // TODO
 			}
 			int nPeriodFrac = 0;
 			// Instrument Auto-Vibrato


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-08-30 00:07:38

Revision: 348
          http://modplug.svn.sourceforge.net/modplug/?rev=348&view=rev
Author:   saga-games
Date:     2009-08-30 00:07:19 +0000 (Sun, 30 Aug 2009)

Log Message:
-----------
[Fix] Rearrange Samples: Also remap samples on instrument "keyboard" that were removed, so that f.e. instruments with VSTis won't have unwanted samples suddenly
[Fix] Order list: After inserting a single order, the list is now no more in multi-order mode.
[Imp] Order list: Enable multi-order mode also when using shift + cursor keys
[Ref] Some internal refactoring

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/Ctrl_pat.h
    trunk/OpenMPT/mptrack/Ctrl_seq.cpp
    trunk/OpenMPT/mptrack/Modedit.cpp
    trunk/OpenMPT/mptrack/tagging.cpp

Modified: trunk/OpenMPT/mptrack/Ctrl_pat.h
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_pat.h	2009-08-29 14:56:14 UTC (rev 347)
+++ trunk/OpenMPT/mptrack/Ctrl_pat.h	2009-08-30 00:07:19 UTC (rev 348)
@@ -44,6 +44,9 @@
 	void InvalidateSelection() const;
 	UINT GetCurrentPattern() const;
 	ORD_SELECTION GetCurSel(bool bIgnoreSelection) const;
+	// make the current selection the secondary selection (used for keyboard orderlist navigation)
+	inline void SetCurSelTo2ndSel()
+		{if(m_bShift && m_nScrollPos2nd == ORDERINDEX_INVALID) m_nScrollPos2nd = m_nScrollPos; else if(!m_bShift && m_nScrollPos2nd != ORDERINDEX_INVALID) m_nScrollPos2nd = ORDERINDEX_INVALID;};
 	bool SetCurSel(ORDERINDEX sel, bool bEdit = true, bool bShiftClick = false);
 	BOOL ProcessKeyDown(UINT nChar);
 	BOOL ProcessChar(UINT nChar);
@@ -71,7 +74,7 @@
 	// Returns the number of sequence items visible in the list.
 	BYTE GetLength();
 
-	// Return true iff given order is in margins given that first shown order
+	// Return true if given order is in margins given that first shown order
 	// is 'startOrder'. Begin part of the whole sequence
 	// is not interpreted to be in margins regardless of the margin value.
 	bool IsOrderInMargins(int order, int startOrder);

Modified: trunk/OpenMPT/mptrack/Ctrl_seq.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Ctrl_seq.cpp	2009-08-29 14:56:14 UTC (rev 347)
+++ trunk/OpenMPT/mptrack/Ctrl_seq.cpp	2009-08-30 00:07:19 UTC (rev 348)
@@ -307,10 +307,10 @@
 	switch(nChar)
 	{
 	case VK_UP:
-	case VK_LEFT:	SetCurSel(m_nScrollPos - 1); break;
+	case VK_LEFT:	SetCurSelTo2ndSel(); SetCurSel(m_nScrollPos - 1); break;
 	case VK_DOWN:
-	case VK_RIGHT:	SetCurSel(m_nScrollPos + 1); break;
-	case VK_HOME:	SetCurSel(0); break;
+	case VK_RIGHT:	SetCurSelTo2ndSel(); SetCurSel(m_nScrollPos + 1); break;
+	case VK_HOME:	SetCurSelTo2ndSel(); SetCurSel(0); break;
 	case VK_END:
 		if (m_pModDoc)
 		{
@@ -318,6 +318,7 @@
 			ORDERINDEX i = 0;
 			const int nSeqLength = pSndFile->Order.size();
 			for (i=0; i+1 < nSeqLength; i++) if (pSndFile->Order[i+1] == pSndFile->Order.GetInvalidPatIndex()) break;
+			SetCurSelTo2ndSel();
 			SetCurSel(i);
 		}
 		break;
@@ -928,7 +929,10 @@
 				pSndFile->Order[nInsertEnd + i + 1] = pSndFile->Order[nInsertEnd - nInsertCount + i];
 		}
 		m_nScrollPos = min(nInsertEnd + 1, pSndFile->Order.GetCount() - 1);
-		m_nScrollPos2nd = min(m_nScrollPos + nInsertCount, pSndFile->Order.GetCount() - 1);
+		if(nInsertCount > 0)
+			m_nScrollPos2nd = min(m_nScrollPos + nInsertCount, pSndFile->Order.GetCount() - 1);
+		else
+			m_nScrollPos2nd = ORDERINDEX_INVALID;
 		InvalidateRect(NULL, FALSE);
 		m_pModDoc->SetModified();
 		m_pModDoc->UpdateAllViews(NULL, HINT_MODSEQUENCE, this);

Modified: trunk/OpenMPT/mptrack/Modedit.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Modedit.cpp	2009-08-29 14:56:14 UTC (rev 347)
+++ trunk/OpenMPT/mptrack/Modedit.cpp	2009-08-30 00:07:19 UTC (rev 348)
@@ -1060,7 +1060,7 @@
 		nSampleMap[i] = i;
 
 	// First, find out which sample slots are unused and create the new sample map
-	for(UINT i = 1 ; i <= m_SndFile.m_nSamples; i++) {
+	for(SAMPLEINDEX i = 1 ; i <= m_SndFile.m_nSamples; i++) {
 		if(!m_SndFile.Samples[i].pSample)
 		{
 			// Move all following samples
@@ -1077,21 +1077,21 @@
 	BEGIN_CRITICAL();
 
 	// Now, move everything around
-	for(UINT i = 1; i <= m_SndFile.m_nSamples; i++)
+	for(SAMPLEINDEX i = 1; i <= m_SndFile.m_nSamples; i++)
 	{
-		if(nSampleMap[i] && nSampleMap[i] != i)
+		if(nSampleMap[i] != i)
 		{
 			// This gotta be moved
 			m_SndFile.MoveSample(i, nSampleMap[i]);
 			m_SndFile.Samples[i].pSample = nullptr;
 			strcpy(m_SndFile.m_szNames[nSampleMap[i]], m_SndFile.m_szNames[i]);
-			m_SndFile.m_szNames[i][0] = '\0';
+			memset(m_SndFile.m_szNames[i], 0, sizeof(m_SndFile.m_szNames[i]));
 
 			// Also update instrument mapping (if module is in instrument mode)
-			for(UINT iInstr = 1; iInstr <= m_SndFile.m_nInstruments; iInstr++){
+			for(INSTRUMENTINDEX iInstr = 1; iInstr <= m_SndFile.m_nInstruments; iInstr++){
 				if(m_SndFile.Instruments[iInstr]){
 					MODINSTRUMENT *p = m_SndFile.Instruments[iInstr];
-					for(WORD iNote =0; iNote < 128; iNote++)
+					for(WORD iNote = 0; iNote < 128; iNote++)
 						if(p->Keyboard[iNote] == i) p->Keyboard[iNote] = nSampleMap[i];
 				}
 			}
@@ -1101,12 +1101,12 @@
 	// Go through the patterns and remap samples (if module is in sample mode)
 	if(!m_SndFile.m_nInstruments)
 	{
-		for (UINT nPat=0; nPat < m_SndFile.Patterns.Size(); nPat++) if (m_SndFile.Patterns[nPat])
+		for (PATTERNINDEX nPat = 0; nPat < m_SndFile.Patterns.Size(); nPat++) if (m_SndFile.Patterns[nPat])
 		{
 			MODCOMMAND *m = m_SndFile.Patterns[nPat];
-			for (UINT len = m_SndFile.PatternSize[nPat] * m_SndFile.m_nChannels; len; m++, len--)
+			for(UINT len = m_SndFile.PatternSize[nPat] * m_SndFile.m_nChannels; len; m++, len--)
 			{
-				if(nSampleMap[m->instr]) m->instr = nSampleMap[m->instr];
+				if(m->instr <= m_SndFile.m_nSamples) m->instr = nSampleMap[m->instr];
 			}
 		}
 	}
@@ -1698,7 +1698,7 @@
 	}
 	if ((!m_SndFile.m_nInstruments) && ((m_SndFile.m_nSamples > 1) || (m_SndFile.Samples[1].pSample)))
 	{
-		if (pDup) return -1;
+		if (pDup) return INSTRUMENTINDEX_INVALID;
 		UINT n = CMainFrame::GetMainFrame()->MessageBox("Convert existing samples to instruments first?", NULL, MB_YESNOCANCEL|MB_ICONQUESTION);
 		if (n == IDYES)
 		{
@@ -1713,7 +1713,7 @@
 					if (!p)
 					{
 						ErrorBox(IDS_ERR_OUTOFMEMORY, CMainFrame::GetMainFrame());
-						return -1;
+						return INSTRUMENTINDEX_INVALID;
 					}
 					InitializeInstrument(p, smp);
 					m_SndFile.Instruments[smp] = p;

Modified: trunk/OpenMPT/mptrack/tagging.cpp
===================================================================
--- trunk/OpenMPT/mptrack/tagging.cpp	2009-08-29 14:56:14 UTC (rev 347)
+++ trunk/OpenMPT/mptrack/tagging.cpp	2009-08-30 00:07:19 UTC (rev 348)
@@ -1,5 +1,5 @@
 /*
- * Purpose: File tagging (ID3v2, RIFF + more iIn the future)
+ * Purpose: File tagging (ID3v2, RIFF + more in the future)
  * Authors: OpenMPT Devs
 */
 


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-08-29 14:56:28

Revision: 347
          http://modplug.svn.sourceforge.net/modplug/?rev=347&view=rev
Author:   saga-games
Date:     2009-08-29 14:56:14 +0000 (Sat, 29 Aug 2009)

Log Message:
-----------
[Fix] MP3 Tagging: Synchsafe integers were calculated wrong; Writing the comments field last so the chance of fucking up everything is lower (Winamp's tag reader seems to have some problems with my long comments, but they seem to be encoded correctly? :-S)
[Fix] XM Compatibility: Note Off with instrument number causes fadeout for samples that have no envelope.
[Imp] Comments tab: Default view mode is instruments instead of samples for XM files.

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/tagging.cpp
    trunk/OpenMPT/mptrack/view_com.cpp
    trunk/OpenMPT/soundlib/Load_psm.cpp
    trunk/OpenMPT/soundlib/Snd_fx.cpp

Modified: trunk/OpenMPT/mptrack/tagging.cpp
===================================================================
--- trunk/OpenMPT/mptrack/tagging.cpp	2009-08-29 00:40:26 UTC (rev 346)
+++ trunk/OpenMPT/mptrack/tagging.cpp	2009-08-29 14:56:14 UTC (rev 347)
@@ -1,5 +1,5 @@
 /*
- * Purpose: File tagging (ID3v2, RIFF + more in the future)
+ * Purpose: File tagging (ID3v2, RIFF + more iIn the future)
  * Authors: OpenMPT Devs
 */
 
@@ -23,15 +23,15 @@
 // Convert Integer to Synchsafe Integer (see ID3v2.4 specs)
 // Basically, it's a BigEndian integer, but the MSB of all bytes is 0.
 // Thus, a 32-bit integer turns into a 28-bit integer.
-UINT32 CFileTagging::intToSynchsafe(UINT32 in)
+UINT32 CFileTagging::intToSynchsafe(UINT32 iIn)
 {
-	in = LittleEndian(in);
-	UINT32 out = 0;
+	iIn = LittleEndian(iIn);
+	UINT32 iOut = 0, iSteps = 0;
 	do {
-		out <<= 8;
-		out |= (in & 0x7F);
-	} while(in >>= 7);
-	return BigEndian(out);
+		iOut |= (iIn & 0x7F) << iSteps;
+		iSteps += 8;
+	} while(iIn >>= 7);
+	return BigEndian(iOut);
 }
 
 // Write Tags
@@ -53,7 +53,7 @@
 	tHeader.flags = 0x00; // No flags
 	fwrite(&tHeader, 1, sizeof(tHeader), f);
 
-	// Write TIT2 (Title), TCOM / TPE1 (Composer), TALB (Album), TCON (Genre), TYER (Date), WXXX (URL), COMM (Comment), TENC (Encoder)
+	// Write TIT2 (Title), TCOM / TPE1 (Composer), TALB (Album), TCON (Genre), TYER (Date), WXXX (URL), TENC (Encoder), COMM (Comment)
 	WriteID3v2Frame("TIT2", title, f);
 	WriteID3v2Frame("TPE1", artist, f);
 	WriteID3v2Frame("TCOM", artist, f);
@@ -61,8 +61,8 @@
 	WriteID3v2Frame("TCON", genre, f);
 	WriteID3v2Frame("TYER", year, f);
 	WriteID3v2Frame("WXXX", url, f);
+	WriteID3v2Frame("TENC", encoder, f);
 	WriteID3v2Frame("COMM", comments, f);
-	WriteID3v2Frame("TENC", encoder, f);
 
 	// Write Padding
 	for(UINT i = 0; i < ID3v2_PADDING; i++)

Modified: trunk/OpenMPT/mptrack/view_com.cpp
===================================================================
--- trunk/OpenMPT/mptrack/view_com.cpp	2009-08-29 00:40:26 UTC (rev 346)
+++ trunk/OpenMPT/mptrack/view_com.cpp	2009-08-29 14:56:14 UTC (rev 347)
@@ -97,13 +97,30 @@
 //----------------------------
 {
 	m_nCurrentListId = 0;
-	m_nListId = IDC_LIST_SAMPLES;
+	m_nListId = 0;//IDC_LIST_SAMPLES;
 }
 
 
 void CViewComments::OnInitialUpdate()
 //-----------------------------------
 {
+	if(m_nListId == 0)
+	{
+		m_nListId = IDC_LIST_SAMPLES;
+
+		// For XM, set the instrument list as the default list
+		CModDoc *pModDoc = GetDocument();
+		CSoundFile *pSndFile;
+		if(pModDoc)
+		{
+			pSndFile= pModDoc->GetSoundFile();
+			if(pSndFile && (pSndFile->m_nType & MOD_TYPE_XM))
+			{
+				m_nListId = IDC_LIST_INSTRUMENTS;
+			}
+		}
+	}
+
 	CChildFrame *pFrame = (CChildFrame *)GetParentFrame();
 	CRect rect;
 

Modified: trunk/OpenMPT/soundlib/Load_psm.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_psm.cpp	2009-08-29 00:40:26 UTC (rev 346)
+++ trunk/OpenMPT/soundlib/Load_psm.cpp	2009-08-29 14:56:14 UTC (rev 347)
@@ -15,6 +15,7 @@
  *  - Sinaria - Seems to work (never played the game, so I can't really tell...)
  *
  * Effect conversion should be about right...
+ * If OpenMPT will ever support subtunes properly, the subtune crap should be rewritten completely.
  */
 
 #include "stdafx.h"

Modified: trunk/OpenMPT/soundlib/Snd_fx.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Snd_fx.cpp	2009-08-29 00:40:26 UTC (rev 346)
+++ trunk/OpenMPT/soundlib/Snd_fx.cpp	2009-08-29 14:56:14 UTC (rev 347)
@@ -1233,8 +1233,8 @@
 					note = instr = 0;
 				}
 
-				// XM: Key-Off + Sample == Note Cut
-				if ((note == NOTE_KEYOFF) && ((!pChn->pModInstrument) || (!(pChn->pModInstrument->dwFlags & ENV_VOLUME))))
+				// XM: Key-Off + Sample == Note Cut (BUT: Only if no instr number is present!)
+				if ((note == NOTE_KEYOFF) && (!pChn->pModInstrument || !IsCompatibleMode(TRK_FASTTRACKER2)) && ((!pChn->pModInstrument) || (!(pChn->pModInstrument->dwFlags & ENV_VOLUME))))
 				{
 					pChn->dwFlags |= CHN_FASTVOLRAMP;
 					pChn->nVolume = 0;


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

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

From: <sag...@us...> - 2009-08-29 00:40:36

Revision: 346
          http://modplug.svn.sourceforge.net/modplug/?rev=346&view=rev
Author:   saga-games
Date:     2009-08-29 00:40:26 +0000 (Sat, 29 Aug 2009)

Log Message:
-----------
[Fix] IT Compatibility: Don't reset channel panning if panbrello ends (experimental)
[Imp] PSM Loader: I think it's finished... finally. Subsongs should work perfectly, a few other things have also been fixed / improved.

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/Moddoc.cpp
    trunk/OpenMPT/soundlib/Load_psm.cpp
    trunk/OpenMPT/soundlib/Sndfile.cpp
    trunk/OpenMPT/soundlib/Sndmix.cpp

Modified: trunk/OpenMPT/mptrack/Moddoc.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Moddoc.cpp	2009-08-26 22:04:14 UTC (rev 345)
+++ trunk/OpenMPT/mptrack/Moddoc.cpp	2009-08-29 00:40:26 UTC (rev 346)
@@ -354,9 +354,9 @@
 	case MOD_TYPE_STM:
 	case MOD_TYPE_DSM:
 	case MOD_TYPE_AMF:
-	case MOD_TYPE_PSM:
 		m_SndFile.ChangeModTypeTo(MOD_TYPE_S3M);
 		break;
+	case MOD_TYPE_PSM:
 	default:
 		m_SndFile.ChangeModTypeTo(MOD_TYPE_IT);
 	}

Modified: trunk/OpenMPT/soundlib/Load_psm.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_psm.cpp	2009-08-26 22:04:14 UTC (rev 345)
+++ trunk/OpenMPT/soundlib/Load_psm.cpp	2009-08-29 00:40:26 UTC (rev 346)
@@ -8,12 +8,11 @@
  *
  * What's playing?
  *  - Epic Pinball - Perfect! (the old tunes in PSM16 format are not supported)
- *  - Extreme Pinball - Default tempo / speed / restart position of subtunes is missing.
- *    I'm using the last default values, restart position is still completely missing
+ *  - Extreme Pinball - Perfect! (subtunes included!)
  *  - Jazz Jackrabbit - Perfect!
- *  - One Must Fall! - Perfect! (I modelled the volume slide and portamento conversion after this, as I got the original MTM files)
+ *  - One Must Fall! - Perfect! (it helped a lot to have the original MTM files...)
  *  - Silverball - Currently not supported (old PSM16 format)
- *  - Sinaria - Seems to work more or less (never played the game, so I can't really tell...)
+ *  - Sinaria - Seems to work (never played the game, so I can't really tell...)
  *
  * Effect conversion should be about right...
  */
@@ -77,6 +76,26 @@
 };
 #pragma pack()
 
+struct PSMSUBSONG // For internal use (pattern conversion)
+{
+	BYTE channelPanning[MAX_BASECHANNELS], channelVolume[MAX_BASECHANNELS];
+	bool channelSurround[MAX_BASECHANNELS];
+	BYTE defaultTempo, defaultSpeed;
+	CHAR songName[10];
+	ORDERINDEX startOrder, endOrder, restartPos;
+
+	PSMSUBSONG() {
+		memset(channelPanning, 128, sizeof(channelPanning));
+		memset(channelVolume, 64, sizeof(channelVolume));
+		memset(channelSurround, false, sizeof(channelSurround));
+		memset(songName, 0, sizeof(songName));
+		defaultTempo = 125;
+		defaultSpeed = 6;
+		startOrder = endOrder = restartPos = ORDERINDEX_INVALID;
+	}
+};
+
+// Portamento effect conversion (depending on format version)
 inline BYTE convert_psm_porta(BYTE param, bool bNewFormat)
 {
 	return ((bNewFormat) ? (param) : ((param < 4) ? (param | 0xF0) : (param >> 2)));
@@ -100,7 +119,8 @@
 		) return false;
 
 	// Yep, this seems to be a valid file.
-	m_nType = MOD_TYPE_PSM;
+	m_nType = MOD_TYPE_IT;
+	SetModFlag(MSF_COMPATIBLE_PLAY, true);
 	m_nChannels = 0;
 
 	dwMemPos += 12;
@@ -110,15 +130,18 @@
 	m_nVSTiVolume = m_nSamplePreAmp = 48; // not supported in this format, so use a good default value
 
 	// pattern offset and identifier
-	PATTERNINDEX numPatterns = 0;
-	vector<DWORD> patternOffsets;
-	vector<DWORD> patternIDs;
+	PATTERNINDEX numPatterns = 0; // used for setting up the orderlist - final pattern count
+	vector<DWORD> patternOffsets; // pattern offsets (sorted as they occour in the file)
+	vector<DWORD> patternIDs; // pattern IDs (sorted as they occour in the file)
+	vector<DWORD> orderOffsets; // combine the upper two vectors to get the offsets for each order item
 	patternOffsets.clear();
 	patternIDs.clear();
+	orderOffsets.clear();
 	Order.clear();
+	// subsong setup
+	vector<PSMSUBSONG> subsongs;
+	bool bSubsongPanningDiffers = false; // do we have subsongs with different panning positions?
 
-	std::string sComment; // we will store some information about the tune here
-
 	while(dwMemPos + 8 < dwMemLength)
 	{
 		// Skip through the chunks
@@ -141,39 +164,37 @@
 			break;
 
 		case 0x444F4250: // "PBOD" - Pattern data of a single pattern
-			if(chunkSize < 4 || chunkSize != LittleEndian(*(DWORD *)(lpStream + dwMemPos))) return false; // same value twice
+			if(chunkSize < 8 || chunkSize != LittleEndian(*(DWORD *)(lpStream + dwMemPos))) return false; // same value twice
 
-			// Pattern ID (something like "P0  " or "P13 ") follows
+			// Pattern ID (something like "P0  " or "P13 ", or "PATT0   " in Sinaria) follows
 			if(memcmp(lpStream + dwMemPos + 4, "P", 1)) return false;
 			if(!memcmp(lpStream + dwMemPos + 4, "PATT", 4)) bNewFormat = true;
+			if(bNewFormat && chunkSize < 12) return false; // 4 additional bytes
+
 			char patternID[4];
 			memcpy(patternID, lpStream + dwMemPos + 5 + (bNewFormat ? 3 : 0), 3);
 			patternID[3] = 0;
+			patternIDs.push_back(atoi(patternID));
 			patternOffsets.push_back(dwMemPos + 8 + (bNewFormat ? 4 : 0));
-			patternIDs.push_back(atoi(patternID));
-			numPatterns++;
 
 			// Convert later as we have to know how many channels there are.
 			break;
 
-		case 0x474E4F53: // "SONG" - Information about this file (channel count etc)
-			// We will not check for the "song type", because it is not ALWAYS "MAINSONG " (Extreme Pinball seems to use other song types for the sub songs)
-			// However, the last char always seems to be a space char.
+		case 0x474E4F53: // "SONG" - Subsong information (channel count etc)
 			{
 				if(chunkSize < sizeof(PSMSONGHEADER)) return false;
 				PSMSONGHEADER *pSong = (PSMSONGHEADER *)(lpStream + dwMemPos);
-				if(pSong->compression != 0x01) return false;
-				m_nChannels = max(m_nChannels, pSong->numChannels); // subsongs *might* have different channel count
+				if(pSong->compression != 0x01) return false; // no compression for PSM files
+				m_nChannels = CLAMP(pSong->numChannels, m_nChannels, MAX_BASECHANNELS); // subsongs *might* have different channel count
 
-				CHAR cSongName[10];
-				memcpy(cSongName, &pSong->songType, 9);
-				cSongName[9] = 0;
-				sComment += "\r\nSubsong: ";
-				sComment += cSongName;
+				PSMSUBSONG subsong;
+				subsong.restartPos = (ORDERINDEX)Order.size(); // restart order "offset": current orderlist length
+				memcpy(subsong.songName, &pSong->songType, 9); // subsong name
+				subsong.songName[9] = 0;
 
 				DWORD dwChunkPos = dwMemPos + sizeof(PSMSONGHEADER);
 
-				// Sub chunks
+				// "Sub sub chunks"
 				while(dwChunkPos + 8 < dwMemPos + chunkSize)
 				{
 					DWORD subChunkID = LittleEndian(*(DWORD *)(lpStream + dwChunkPos));
@@ -190,20 +211,11 @@
 							memcpy(cversion, lpStream + dwChunkPos, 6);
 							cversion[6] = 0;
 							int version = atoi(cversion);
-							// Sinaria song dates
+							// Sinaria song dates (just to go sure...)
 							if(version == 800211 || version == 940902 || version == 940903 ||
 								version == 940906 || version == 940914 || version == 941213)
 								bNewFormat = true;
 						}
-						#ifdef DEBUG
-						CHAR cDate[7];
-						memcpy(cDate, lpStream + dwChunkPos, 6);
-						cDate[6] = 0;
-						sComment += " - Build Date: ";
-						sComment += cDate;
-						if(bNewFormat) sComment += " (New Format)";
-						else sComment += " (Old Format)";
-						#endif
 						break;
 
 					case 0x484C504F: // "OPLH" - Order list, channel + module settings
@@ -215,6 +227,8 @@
 							// Now, the interesting part begins!
 							DWORD dwSettingsOffset = dwChunkPos + 2;
 							WORD nChunkCount = 0, nFirstOrderChunk = (WORD)-1;
+
+							// "Sub sub sub chunks" (grrrr, silly format)
 							while(dwSettingsOffset - dwChunkPos + 1 < subChunkSize)
 							{
 								switch(lpStream[dwSettingsOffset])
@@ -226,57 +240,62 @@
 								case 0x01: // Order list item
 									if(dwSettingsOffset - dwChunkPos + 5 > subChunkSize) return false;
 									// Pattern name follows - find pattern (this is the orderlist)
-									for(PATTERNINDEX i = 0; i < patternIDs.size(); i++)
 									{
-										char patternID[4];
+										char patternID[4]; // temporary
 										memcpy(patternID, lpStream + dwSettingsOffset + 2 + (bNewFormat ? 3 : 0), 3);
 										patternID[3] = 0;
 										DWORD nPattern = atoi(patternID);
-										if(patternIDs[i] == nPattern)
+
+										// seek which pattern has this ID
+										for(uint32 i = 0; i < patternIDs.size(); i++)
 										{
-											Order.push_back(i);
-											break;
+											if(patternIDs[i] == nPattern)
+											{
+												// found the right pattern, copy offset + start / end positions.
+												if(subsong.startOrder == ORDERINDEX_INVALID)
+													subsong.startOrder = (ORDERINDEX)orderOffsets.size();
+												subsong.endOrder = (ORDERINDEX)orderOffsets.size();
+
+												// every pattern in the order will be unique, so store the pointer + pattern ID
+												orderOffsets.push_back(patternOffsets[i]);
+												Order.push_back(numPatterns);
+												numPatterns++;
+												break;
+											}
 										}
 									}
+									// decide whether this is the first order chunk or not (for finding out the correct restart position)
 									if(nFirstOrderChunk == (WORD)-1) nFirstOrderChunk = nChunkCount;
 									dwSettingsOffset += 5 + (bNewFormat ? 4 : 0);
 									break;
 
 								case 0x04: // Restart position
 									{
-										// NOTE: This should not be global! (Extreme Pinball!!!)
 										WORD nRestartChunk = LittleEndian(*(WORD *)(lpStream + dwSettingsOffset + 1));
 										ORDERINDEX nRestartPosition = 0;
-										if(nRestartChunk == 0) nRestartPosition = 0;
-										else if(nRestartChunk >= nFirstOrderChunk) nRestartPosition = (ORDERINDEX)(nRestartChunk - nFirstOrderChunk);
-										#ifdef DEBUG
-										{
-											char s[32];
-											wsprintf(s, " - restart pos %d", nRestartPosition);
-											sComment += s;
-										}
-										#endif
+										if(nRestartChunk >= nFirstOrderChunk) nRestartPosition = (ORDERINDEX)(nRestartChunk - nFirstOrderChunk);
+										subsong.restartPos += nRestartPosition;
+										m_nRestartPos = subsong.restartPos;
 									}
 									dwSettingsOffset += 3;
 									break;
 
 								case 0x07: // Default Speed
 									if(dwSettingsOffset - dwChunkPos + 2 > subChunkSize) break;
-									// Same note as above!
-									m_nDefaultSpeed =  lpStream[dwSettingsOffset + 1];
+									m_nDefaultSpeed = subsong.defaultSpeed = lpStream[dwSettingsOffset + 1];
 									dwSettingsOffset += 2;
 									break;
 
 								case 0x08: // Default Tempo
 									if(dwSettingsOffset - dwChunkPos + 2 > subChunkSize) break;
-									// Same note as above!
-									m_nDefaultTempo =  lpStream[dwSettingsOffset + 1];
+									m_nDefaultTempo =  subsong.defaultTempo =  lpStream[dwSettingsOffset + 1];
 									dwSettingsOffset += 2;
 									break;
 
 								case 0x0C: // Sample map table (???)
 									if(dwSettingsOffset - dwChunkPos + 7 > subChunkSize) break;
 
+									// Never seems to be different, so...
 									if (lpStream[dwSettingsOffset + 1] != 0x00 || lpStream[dwSettingsOffset + 2] != 0xFF ||
 										lpStream[dwSettingsOffset + 3] != 0x00 || lpStream[dwSettingsOffset + 4] != 0x00 ||
 										lpStream[dwSettingsOffset + 5] != 0x01 || lpStream[dwSettingsOffset + 6] != 0x00)
@@ -287,31 +306,44 @@
 								case 0x0D: // Channel panning table
 									if(dwSettingsOffset - dwChunkPos + 4 > subChunkSize) break;
 
+									if(lpStream[dwSettingsOffset + 1] < MAX_BASECHANNELS)
 									{
-										CHANNELINDEX nChn = min(lpStream[dwSettingsOffset + 1], pSong->numChannels);
+										CHANNELINDEX nChn = lpStream[dwSettingsOffset + 1];
 										switch(lpStream[dwSettingsOffset + 3])
 										{
-										case 0:
-											ChnSettings[nChn].nPan = lpStream[dwSettingsOffset + 2] ^ 128;
+										case 0: // use panning
+											ChnSettings[nChn].nPan = subsong.channelPanning[nChn] = lpStream[dwSettingsOffset + 2] ^ 128;
+											ChnSettings[nChn].dwFlags &= ~CHN_SURROUND;
+											subsong.channelSurround[nChn] = false;
 											break;
 
-										case 2:
-											ChnSettings[nChn].nPan = 128;
+										case 2: // surround
+											ChnSettings[nChn].nPan = subsong.channelPanning[nChn] = 128;
 											ChnSettings[nChn].dwFlags |= CHN_SURROUND;
+											subsong.channelSurround[nChn] = true;
 											break;
 
-										case 4:
-											ChnSettings[nChn].nPan = 128;
+										case 4: // center
+											ChnSettings[nChn].nPan = subsong.channelPanning[nChn] = 128;
+											ChnSettings[nChn].dwFlags &= ~CHN_SURROUND;
+											subsong.channelSurround[nChn] = false;
 											break;
 
 										}
+										if(bSubsongPanningDiffers == false && subsongs.size() > 0)
+										{
+											if(subsongs.back().channelPanning[nChn] != subsong.channelPanning[nChn]
+												|| subsongs.back().channelSurround[nChn] != subsong.channelSurround[nChn])
+												bSubsongPanningDiffers = true;
+										}
 									}
 									dwSettingsOffset += 4;
 									break;
 
-								case 0x0E: // Channel volume table
+								case 0x0E: // Channel volume table (0...255)
 									if(dwSettingsOffset - dwChunkPos + 3 > subChunkSize) break;
-									ChnSettings[min(lpStream[dwSettingsOffset + 1], pSong->numChannels)].nVolume = (lpStream[dwSettingsOffset + 2] >> 2) + 1;
+									if(lpStream[dwSettingsOffset + 1] < MAX_BASECHANNELS)
+										ChnSettings[lpStream[dwSettingsOffset + 1]].nVolume = subsong.channelVolume[lpStream[dwSettingsOffset + 1]] = (lpStream[dwSettingsOffset + 2] >> 2) + 1;
 
 									dwSettingsOffset += 3;
 									break;
@@ -320,12 +352,15 @@
 									CString s;
 									s.Format("Please report to the OpenMPT team: Unknown chunk %d found at position %d (in the OPLH chunk of this PSM file)", lpStream[dwSettingsOffset], dwSettingsOffset);
 									MessageBox(NULL, s, TEXT("OpenMPT PSM import"), MB_ICONERROR);
+									// anyway, in such cases, we have to quit as we don't know how big the chunk really is.
 									return false;
 									break;
 
 								}
 								nChunkCount++;
 							}
+							// separate subsongs by "---" patterns
+							orderOffsets.push_back(nullptr);
 							Order.push_back(Order.GetInvalidPatIndex());
 						}
 						break;
@@ -334,20 +369,26 @@
 						if(subChunkSize & 1) return false;
 						for(DWORD i = 0; i < subChunkSize; i += 2)
 						{
-							if((i >> 1) >= m_nChannels) break;
+							CHANNELINDEX nChn = (CHANNELINDEX)(i >> 1);
+							if(nChn >= m_nChannels) break;
 							switch(lpStream[dwChunkPos + i])
 							{
-							case 0:
-								ChnSettings[i >> 1].nPan = lpStream[dwChunkPos + i + 1] ^ 128;
+							case 0: // use panning
+								ChnSettings[nChn].nPan = subsong.channelPanning[nChn] = lpStream[dwChunkPos + i + 1] ^ 128;
+								ChnSettings[nChn].dwFlags &= ~CHN_SURROUND;
+								subsong.channelSurround[nChn] = false;
 								break;
 
-							case 2:
-								ChnSettings[i >> 1].nPan = 128;
-								ChnSettings[i >> 1].dwFlags |= CHN_SURROUND;
+							case 2: // surround
+								ChnSettings[nChn].nPan = subsong.channelPanning[nChn] = 128;
+								ChnSettings[nChn].dwFlags |= CHN_SURROUND;
+								subsong.channelSurround[nChn] = true;
 								break;
 
-							case 4:
-								ChnSettings[i >> 1].nPan = 128;
+							case 4: // center
+								ChnSettings[nChn].nPan = subsong.channelPanning[nChn] = 128;
+								ChnSettings[nChn].dwFlags &= ~CHN_SURROUND;
+								subsong.channelSurround[nChn] = false;
 								break;
 							}
 						}
@@ -368,6 +409,9 @@
 
 					dwChunkPos += subChunkSize;
 				}
+
+				// attach this subsong to the subsong list - finally, all "sub sub sub ..." chunks are parsed.
+				subsongs.push_back(subsong);
 			}
 
 			break;
@@ -375,6 +419,7 @@
 		case 0x504D5344: // DSMP - Samples
 			if(!bNewFormat)
 			{
+				// original header
 				if(chunkSize < sizeof(PSMOLDSAMPLEHEADER)) return false;
 				PSMOLDSAMPLEHEADER *pSample = (PSMOLDSAMPLEHEADER *)(lpStream + dwMemPos);
 				SAMPLEINDEX smp = (SAMPLEINDEX)(LittleEndianW(pSample->sampleNumber) + 1);
@@ -434,10 +479,14 @@
 
 	if(m_nChannels == 0)
 		return false;
+
 	// Now that we know the number of channels, we can go through all the patterns.
-	for(PATTERNINDEX nPat = 0; nPat < numPatterns; nPat++)
+	// This is a bit stupid since we will even read duplicate patterns twice, but hey, we do this just once... so who cares?
+	PATTERNINDEX nPat = 0;
+	for(ORDERINDEX nOrd = 0; nOrd < Order.size(); nOrd++)
 	{
-		DWORD dwPatternOffset = patternOffsets[nPat];
+		if(orderOffsets[nOrd] == nullptr) continue;
+		DWORD dwPatternOffset = orderOffsets[nOrd];
 		if(dwPatternOffset + 2 > dwMemLength) return false;
 		WORD patternSize = LittleEndianW(*(WORD *)(lpStream + dwPatternOffset));
 		dwPatternOffset += 2;
@@ -659,11 +708,7 @@
 						break;
 
 					default:
-						#ifdef DEBUG
-						ASSERT(false);
-						#else
 						command = CMD_NONE;
-						#endif
 						break;
 
 					}
@@ -679,17 +724,52 @@
 			row_data += m_nChannels;
 			dwPatternOffset += rowSize;
 		}
-
+		nPat++;
 	}
 
-	if(!sComment.empty())
+	// write subsong "configuration" to patterns
+	for(uint32 i = 0; i < subsongs.size(); i++)
 	{
-		m_lpszSongComments = new char[sComment.length() + 1];
-		if (m_lpszSongComments)
+		PATTERNINDEX startPattern = Order[subsongs[i].startOrder], endPattern = Order[subsongs[i].endOrder];
+		if(startPattern == PATTERNINDEX_INVALID || endPattern == PATTERNINDEX_INVALID) continue; // what, invalid subtune?
+
+		// set the subsong name to all pattern names
+		for(PATTERNINDEX nPat = startPattern; nPat <= endPattern; nPat++)
 		{
-			memset(m_lpszSongComments, 0, sComment.length() + 1);
-			memcpy(m_lpszSongComments, sComment.c_str(), sComment.length());
+			SetPatternName(nPat, subsongs[i].songName);
 		}
+		
+		// subsongs with different panning setup -> write to pattern (MUSIC_C.PSM)
+		if(bSubsongPanningDiffers)
+		{
+			for(CHANNELINDEX nChn = 0; nChn < m_nChannels; nChn++)
+			{
+				if(subsongs[i].channelSurround[nChn] == true)
+					TryWriteEffect(startPattern, 0, CMD_S3MCMDEX, 0x91, false, nChn, false, true);
+				else
+					TryWriteEffect(startPattern, 0, CMD_PANNING8, subsongs[i].channelPanning[nChn], false, nChn, false, true);
+			}
+		}
+		// write default tempo/speed to pattern
+		TryWriteEffect(startPattern, 0, CMD_SPEED, subsongs[i].defaultSpeed, false, CHANNELINDEX_INVALID, false, true);
+		TryWriteEffect(startPattern, 0, CMD_TEMPO, subsongs[i].defaultTempo, false, CHANNELINDEX_INVALID, false, true);
+
+		// don't write channel volume for now, as it's always set to 100% anyway
+
+		// there's a restart pos, so let's try to insert a Bxx command in the last pattern
+		if(subsongs[i].restartPos != ORDERINDEX_INVALID)
+		{
+			ROWINDEX lastRow = Patterns[endPattern].GetNumRows() - 1;
+			MODCOMMAND *row_data;
+			row_data = Patterns[endPattern];
+			for(uint32 nCell = 0; nCell < m_nChannels * Patterns[endPattern].GetNumRows(); nCell++)
+			{
+				if(row_data->command == CMD_PATTERNBREAK || row_data->command == CMD_POSITIONJUMP)
+					lastRow = nCell / m_nChannels;
+				row_data++;
+			}
+			TryWriteEffect(endPattern, lastRow, CMD_POSITIONJUMP, (BYTE)subsongs[i].restartPos, false, CHANNELINDEX_INVALID, false, true);
+		}
 	}
 
 	return true;

Modified: trunk/OpenMPT/soundlib/Sndfile.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Sndfile.cpp	2009-08-26 22:04:14 UTC (rev 345)
+++ trunk/OpenMPT/soundlib/Sndfile.cpp	2009-08-29 00:40:26 UTC (rev 346)
@@ -3119,7 +3119,7 @@
 					if(m_nType & MOD_TYPE_S3M && nParam > 0x80)
 						break;
 
-					m->volcmd = VOLCMD_VOLUME;
+					m->volcmd = VOLCMD_PANNING;
 					m->command = nEffect;
 
 					if(m_nType & MOD_TYPE_S3M)

Modified: trunk/OpenMPT/soundlib/Sndmix.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Sndmix.cpp	2009-08-26 22:04:14 UTC (rev 345)
+++ trunk/OpenMPT/soundlib/Sndmix.cpp	2009-08-29 00:40:26 UTC (rev 346)
@@ -1445,6 +1445,7 @@
 				pdelta += pChn->nRealPan;
 				
 				pChn->nRealPan = CLAMP(pdelta, 0, 256);
+				if(IsCompatibleMode(TRK_IMPULSETRACKER)) pChn->nPan = pChn->nRealPan;
 			}
 			int nPeriodFrac = 0;
 			// Instrument Auto-Vibrato


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

3 messages has been excluded from this view by a project administrator.

Flat | Threaded

<< < 1 .. 947 948 949 950 951 .. 957 > >> (Page 949 of 957)