gearmulator

commit 5e4509612ffbb6bb0dd1da265b05f5e56fc31501
parent 796139f577f120e4d3edd848f63b8a81cab1b298
Author: dsp56300 <dsp56300@users.noreply.github.com>
Date:   Mon, 21 Oct 2024 02:24:13 +0200

store used user waves and tables in state

Diffstat:
M
source/xtLib/xtState.cpp
 | 
97
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
M
source/xtLib/xtState.h
 | 
11
+++++++++++

2 files changed, 108 insertions(+), 0 deletions(-)
diff --git a/source/xtLib/xtState.cpp b/source/xtLib/xtState.cpp
@@ -1,6 +1,7 @@
 #include "xtState.h"
 
 #include <cassert>
+#include <set>
 
 #include "xtMidiTypes.h"
 #include "xt.h"
@@ -41,6 +42,72 @@ namespace xt
 		append(_state, m_mode, ~0u);
 		append(_state, m_global, wLib::IdxCommand);
 
+		// add all waves and tables that are used by the singles
+		std::set<TableId> tableIds;
+
+		auto addTableId = [&](TableId id)
+		{
+			if(wave::isReadOnly(id))
+				return false;
+
+			const auto idx = id.rawId();
+			if(idx >= m_tables.size())
+				return false;
+
+			if(!isValid(m_tables[idx]))
+				return false;
+			tableIds.insert(id);
+			return true;
+		};
+
+		for (const auto& s  : m_currentInstrumentSingles)
+		{
+			const auto table = getWavetableFromSingleDump({s.begin(), s.end()});
+			addTableId(table);
+		}
+		for (const auto& s  : m_currentMultiSingles)
+		{
+			const auto table = getWavetableFromSingleDump({s.begin(), s.end()});
+			addTableId(table);
+		}
+
+		std::set<WaveId> waveIds;
+		for (const TableId id : tableIds)
+		{
+			if(wave::isReadOnly(id))
+				continue;
+
+			const auto idx = id.rawId();
+			if(idx >= m_tables.size())
+				continue;
+
+			const auto& t = m_tables[idx];
+			if(!isValid(t))
+				continue;
+
+			TableData table;
+			parseTableData(table, {t.begin(), t.end()});
+
+			for (const auto& waveId : table)
+			{
+				if(wave::isReadOnly(waveId))
+					continue;
+				const auto waveIdx = waveId.rawId();
+				if(waveIdx >= m_waves.size())
+					continue;
+				const auto& wave = m_waves[waveIdx];
+				if(!isValid(wave))
+					continue;
+				waveIds.insert(waveId);
+			}
+		}
+
+		for (const auto& waveId : waveIds)
+			append(_state, m_waves[waveId.rawId()], wLib::IdxCommand);
+
+		for (const auto& tableId : tableIds)
+			append(_state, m_tables[tableId.rawId()], wLib::IdxCommand);
+
 		const auto multiMode = isMultiMode();
 
 		// if we are in multimode, write multis last, otherwise, write singles last
@@ -155,6 +222,8 @@ namespace xt
 		case SysexCommand::MultiDump:				return parseDump(DumpType::Multi, _data);
 		case SysexCommand::GlobalDump:				return parseDump(DumpType::Global, _data);
 		case SysexCommand::ModeDump:				return parseDump(DumpType::Mode, _data);
+		case SysexCommand::WaveDump:				return parseDump(DumpType::Wave, _data);
+		case SysexCommand::WaveCtlDump:				return parseDump(DumpType::Table, _data);
 
 		case SysexCommand::SingleParameterChange:	return modifyDump(DumpType::Single, _data);
 		case SysexCommand::MultiParameterChange:	return modifyDump(DumpType::Multi, _data);
@@ -292,6 +361,32 @@ namespace xt
 		return true;
 	}
 
+	bool State::parseWaveDump(const SysEx& _data)
+	{
+		const auto idx = (static_cast<uint32_t>(_data[IdxWaveIndexH]) << 7u) | static_cast<uint32_t>(_data[IdxWaveIndexL]);
+
+		if(idx >= m_waves.size())
+			return false;
+
+		if(!convertTo(m_waves[idx], _data))
+			return false;
+
+		return true;
+	}
+
+	bool State::parseTableDump(const SysEx& _data)
+	{
+		const auto idx = (static_cast<uint32_t>(_data[IdxWaveIndexH]) << 7u) | static_cast<uint32_t>(_data[IdxWaveIndexL]);
+
+		if(idx >= m_tables.size())
+			return false;
+
+		if(!convertTo(m_tables[idx], _data))
+			return false;
+
+		return true;
+	}
+
 	bool State::modifySingle(const SysEx& _data)
 	{
 		auto* p = getSingleParameter(_data);
@@ -531,6 +626,8 @@ namespace xt
 		case DumpType::Multi: res = parseMultiDump(_data); break;
 		case DumpType::Global: res = parseGlobalDump(_data); break;
 		case DumpType::Mode: res = parseModeDump(_data); break;
+		case DumpType::Wave: res = parseWaveDump(_data); break;
+		case DumpType::Table: res = parseTableDump(_data); break;
 		default:
 			return false;
 		}
diff --git a/source/xtLib/xtState.h b/source/xtLib/xtState.h
@@ -131,6 +131,8 @@ namespace xt
 		bool parseMultiDump(const SysEx& _data);
 		bool parseGlobalDump(const SysEx& _data);
 		bool parseModeDump(const SysEx& _data);
+		bool parseWaveDump(const SysEx& _data);
+		bool parseTableDump(const SysEx& _data);
 
 		bool modifySingle(const SysEx& _data);
 		bool modifyMulti(const SysEx& _data);
@@ -173,6 +175,11 @@ namespace xt
 			return _single.front() == 0xf0;
 		}
 
+		static bool isValid(const Wave& _single)
+		{
+			return _single.front() == 0xf0;
+		}
+
 		static bool isValid(const Global& _global)
 		{
 			return _global.back() == 0xf7;
@@ -205,6 +212,10 @@ namespace xt
 		std::array<Single, 256> m_romSingles{Single{}};
 		std::array<Multi, 128> m_romMultis{Multi{}};
 
+		// User Waves and Tables
+		std::array<Wave, xt::wave::g_firstRamWaveIndex + xt::wave::g_ramWaveCount> m_waves{Wave{}};
+		std::array<Table, xt::wave::g_tableCount> m_tables{Table{}};
+
 		// Edit Buffers
 		std::array<Single, 8> m_currentMultiSingles{Single{}};
 		std::array<Single, 1> m_currentInstrumentSingles{Single{}};