Initial community commit

Src/external_dependencies/openmpt-trunk/soundlib/pattern.cpp

@@ -0,0 +1,643 @@
+/*
+ * Pattern.cpp
+ * -----------
+ * Purpose: Module Pattern header class
+ * Notes  : (currently none)
+ * Authors: OpenMPT Devs
+ * The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
+ */
+
+
+#include "stdafx.h"
+#include "pattern.h"
+#include "patternContainer.h"
+#include "../common/serialization_utils.h"
+#include "../common/version.h"
+#include "ITTools.h"
+#include "Sndfile.h"
+#include "mod_specifications.h"
+#include "mpt/io/io.hpp"
+#include "mpt/io/io_stdstream.hpp"
+
+
+OPENMPT_NAMESPACE_BEGIN
+
+
+CSoundFile& CPattern::GetSoundFile() { return m_rPatternContainer.GetSoundFile(); }
+const CSoundFile& CPattern::GetSoundFile() const { return m_rPatternContainer.GetSoundFile(); }
+
+
+CHANNELINDEX CPattern::GetNumChannels() const
+{
+	return GetSoundFile().GetNumChannels();
+}
+
+
+// Check if there is any note data on a given row.
+bool CPattern::IsEmptyRow(ROWINDEX row) const
+{
+	if(m_ModCommands.empty() || !IsValidRow(row))
+	{
+		return true;
+	}
+
+	PatternRow data = GetRow(row);
+	for(CHANNELINDEX chn = 0; chn < GetNumChannels(); chn++, data++)
+	{
+		if(!data->IsEmpty())
+		{
+			return false;
+		}
+	}
+	return true;
+}
+
+
+bool CPattern::SetSignature(const ROWINDEX rowsPerBeat, const ROWINDEX rowsPerMeasure)
+{
+	if(rowsPerBeat < 1
+		|| rowsPerBeat > GetSoundFile().GetModSpecifications().patternRowsMax
+		|| rowsPerMeasure < rowsPerBeat
+		|| rowsPerMeasure > GetSoundFile().GetModSpecifications().patternRowsMax)
+	{
+		return false;
+	}
+	m_RowsPerBeat = rowsPerBeat;
+	m_RowsPerMeasure = rowsPerMeasure;
+	return true;
+}
+
+
+// Add or remove rows from the pattern.
+bool CPattern::Resize(const ROWINDEX newRowCount, bool enforceFormatLimits, bool resizeAtEnd)
+{
+	CSoundFile &sndFile = GetSoundFile();
+
+	if(newRowCount == m_Rows || newRowCount < 1 || newRowCount > MAX_PATTERN_ROWS)
+	{
+		return false;
+	}
+	if(enforceFormatLimits)
+	{
+		auto &specs = sndFile.GetModSpecifications();
+		if(newRowCount > specs.patternRowsMax || newRowCount < specs.patternRowsMin) return false;
+	}
+
+	try
+	{
+		size_t count = ((newRowCount > m_Rows) ? (newRowCount - m_Rows) : (m_Rows - newRowCount)) * GetNumChannels();
+
+		if(newRowCount > m_Rows)
+			m_ModCommands.insert(resizeAtEnd ? m_ModCommands.end() : m_ModCommands.begin(), count, ModCommand::Empty());
+		else if(resizeAtEnd)
+			m_ModCommands.erase(m_ModCommands.end() - count, m_ModCommands.end());
+		else
+			m_ModCommands.erase(m_ModCommands.begin(), m_ModCommands.begin() + count);
+	} catch(mpt::out_of_memory e)
+	{
+		mpt::delete_out_of_memory(e);
+		return false;
+	}
+
+	m_Rows = newRowCount;
+	return true;
+}
+
+
+void CPattern::ClearCommands()
+{
+	std::fill(m_ModCommands.begin(), m_ModCommands.end(), ModCommand::Empty());
+}
+
+
+bool CPattern::AllocatePattern(ROWINDEX rows)
+{
+	size_t newSize = GetNumChannels() * rows;
+	if(rows == 0)
+	{
+		return false;
+	} else if(rows == GetNumRows() && m_ModCommands.size() == newSize)
+	{
+		// Re-use allocated memory
+		ClearCommands();
+		return true;
+	} else
+	{
+		// Do this in two steps in order to keep the old pattern data in case of OOM
+		decltype(m_ModCommands) newPattern(newSize, ModCommand::Empty());
+		m_ModCommands = std::move(newPattern);
+	}
+	m_Rows = rows;
+	return true;
+}
+
+
+void CPattern::Deallocate()
+{
+	m_Rows = m_RowsPerBeat = m_RowsPerMeasure = 0;
+	m_ModCommands.clear();
+	m_PatternName.clear();
+}
+
+
+CPattern& CPattern::operator= (const CPattern &pat)
+{
+	m_ModCommands = pat.m_ModCommands;
+	m_Rows = pat.m_Rows;
+	m_RowsPerBeat = pat.m_RowsPerBeat;
+	m_RowsPerMeasure = pat.m_RowsPerMeasure;
+	m_tempoSwing = pat.m_tempoSwing;
+	m_PatternName = pat.m_PatternName;
+	return *this;
+}
+
+
+
+bool CPattern::operator== (const CPattern &other) const
+{
+	return GetNumRows() == other.GetNumRows()
+		&& GetNumChannels() == other.GetNumChannels()
+		&& GetOverrideSignature() == other.GetOverrideSignature()
+		&& GetRowsPerBeat() == other.GetRowsPerBeat()
+		&& GetRowsPerMeasure() == other.GetRowsPerMeasure()
+		&& GetTempoSwing() == other.GetTempoSwing()
+		&& m_ModCommands == other.m_ModCommands;
+}
+
+
+#ifdef MODPLUG_TRACKER
+
+bool CPattern::Expand()
+{
+	const ROWINDEX newRows = m_Rows * 2;
+	const CHANNELINDEX nChns = GetNumChannels();
+
+	if(m_ModCommands.empty()
+		|| newRows > GetSoundFile().GetModSpecifications().patternRowsMax)
+	{
+		return false;
+	}
+
+	decltype(m_ModCommands) newPattern;
+	try
+	{
+		newPattern.assign(m_ModCommands.size() * 2, ModCommand::Empty());
+	} catch(mpt::out_of_memory e)
+	{
+		mpt::delete_out_of_memory(e);
+		return false;
+	}
+
+	for(auto mSrc = m_ModCommands.begin(), mDst = newPattern.begin(); mSrc != m_ModCommands.end(); mSrc += nChns, mDst += 2 * nChns)
+	{
+		std::copy(mSrc, mSrc + nChns, mDst);
+	}
+
+	m_ModCommands = std::move(newPattern);
+	m_Rows = newRows;
+
+	return true;
+}
+
+
+bool CPattern::Shrink()
+{
+	if (m_ModCommands.empty()
+		|| m_Rows < GetSoundFile().GetModSpecifications().patternRowsMin * 2)
+	{
+		return false;
+	}
+
+	m_Rows /= 2;
+	const CHANNELINDEX nChns = GetNumChannels();
+
+	for(ROWINDEX y = 0; y < m_Rows; y++)
+	{
+		const PatternRow srcRow = GetRow(y * 2);
+		const PatternRow nextSrcRow = GetRow(y * 2 + 1);
+		PatternRow destRow = GetRow(y);
+
+		for(CHANNELINDEX x = 0; x < nChns; x++)
+		{
+			const ModCommand &src = srcRow[x];
+			const ModCommand &srcNext = nextSrcRow[x];
+			ModCommand &dest = destRow[x];
+			dest = src;
+
+			if(dest.note == NOTE_NONE && !dest.instr)
+			{
+				// Fill in data from next row if field is empty
+				dest.note = srcNext.note;
+				dest.instr = srcNext.instr;
+				if(srcNext.volcmd != VOLCMD_NONE)
+				{
+					dest.volcmd = srcNext.volcmd;
+					dest.vol = srcNext.vol;
+				}
+				if(dest.command == CMD_NONE)
+				{
+					dest.command = srcNext.command;
+					dest.param = srcNext.param;
+				}
+			}
+		}
+	}
+	m_ModCommands.resize(m_Rows * nChns);
+
+	return true;
+}
+
+
+#endif // MODPLUG_TRACKER
+
+
+bool CPattern::SetName(const std::string &newName)
+{
+	m_PatternName = newName;
+	return true;
+}
+
+
+bool CPattern::SetName(const char *newName, size_t maxChars)
+{
+	if(newName == nullptr || maxChars == 0)
+	{
+		return false;
+	}
+	const auto nameEnd = std::find(newName, newName + maxChars, '\0');
+	m_PatternName.assign(newName, nameEnd);
+	return true;
+}
+
+
+// Write some kind of effect data to the pattern. Exact data to be written and write behaviour can be found in the EffectWriter object.
+bool CPattern::WriteEffect(EffectWriter &settings)
+{
+	// First, reject invalid parameters.
+	if(m_ModCommands.empty()
+		|| settings.m_row >= GetNumRows()
+		|| (settings.m_channel >= GetNumChannels() && settings.m_channel != CHANNELINDEX_INVALID))
+	{
+		return false;
+	}
+
+	CHANNELINDEX scanChnMin = settings.m_channel, scanChnMax = settings.m_channel;
+
+	// Scan all channels
+	if(settings.m_channel == CHANNELINDEX_INVALID)
+	{
+		scanChnMin = 0;
+		scanChnMax = GetNumChannels() - 1;
+	}
+
+	ModCommand * const baseCommand = GetpModCommand(settings.m_row, scanChnMin);
+	ModCommand *m;
+
+	// Scan channel(s) for same effect type - if an effect of the same type is already present, exit.
+	if(!settings.m_allowMultiple)
+	{
+		m = baseCommand;
+		for(CHANNELINDEX i = scanChnMin; i <= scanChnMax; i++, m++)
+		{
+			if(!settings.m_isVolEffect && m->command == settings.m_command)
+				return true;
+			if(settings.m_isVolEffect && m->volcmd == settings.m_volcmd)
+				return true;
+		}
+	}
+
+	// Easy case: check if there's some space left to put the effect somewhere
+	m = baseCommand;
+	for(CHANNELINDEX i = scanChnMin; i <= scanChnMax; i++, m++)
+	{
+		if(!settings.m_isVolEffect && m->command == CMD_NONE)
+		{
+			m->command = settings.m_command;
+			m->param = settings.m_param;
+			return true;
+		}
+		if(settings.m_isVolEffect && m->volcmd == VOLCMD_NONE)
+		{
+			m->volcmd = settings.m_volcmd;
+			m->vol = settings.m_vol;
+			return true;
+		}
+	}
+
+	// Ok, apparently there's no space. If we haven't tried already, try to map it to the volume column or effect column instead.
+	if(settings.m_retry)
+	{
+		const bool isS3M = (GetSoundFile().GetType() & MOD_TYPE_S3M);
+
+		// Move some effects that also work in the volume column, so there's place for our new effect.
+		if(!settings.m_isVolEffect)
+		{
+			m = baseCommand;
+			for(CHANNELINDEX i = scanChnMin; i <= scanChnMax; i++, m++)
+			{
+				switch(m->command)
+				{
+				case CMD_VOLUME:
+					if(!GetSoundFile().GetModSpecifications().HasVolCommand(VOLCMD_VOLUME))
+					{
+						break;
+					}
+					m->volcmd = VOLCMD_VOLUME;
+					m->vol = m->param;
+					m->command = settings.m_command;
+					m->param = settings.m_param;
+					return true;
+
+				case CMD_PANNING8:
+					if(isS3M && m->param > 0x80)
+					{
+						break;
+					}
+
+					m->volcmd = VOLCMD_PANNING;
+					m->command = settings.m_command;
+
+					if(isS3M)
+						m->vol = (m->param + 1u) / 2u;
+					else
+						m->vol = (m->param + 2u) / 4u;
+
+					m->param = settings.m_param;
+					return true;
+
+				default:
+					break;
+				}
+			}
+		}
+
+		// Let's try it again by writing into the "other" effect column.
+		if(settings.m_isVolEffect)
+		{
+			// Convert volume effect to normal effect
+			ModCommand::COMMAND newCommand = CMD_NONE;
+			ModCommand::PARAM newParam = settings.m_vol;
+			switch(settings.m_volcmd)
+			{
+			case VOLCMD_PANNING:
+				newCommand = CMD_PANNING8;
+				newParam = mpt::saturate_cast<ModCommand::PARAM>(settings.m_vol * (isS3M ? 2u : 4u));
+				break;
+			case VOLCMD_VOLUME:
+				newCommand = CMD_VOLUME;
+				break;
+			default:
+				break;
+			}
+
+			if(newCommand != CMD_NONE)
+			{
+				settings.m_command = static_cast<EffectCommand>(newCommand);
+				settings.m_param = newParam;
+				settings.m_retry = false;
+			}
+		} else
+		{
+			// Convert normal effect to volume effect
+			ModCommand::VOLCMD newVolCmd = VOLCMD_NONE;
+			ModCommand::VOL newVol = settings.m_param;
+			if(settings.m_command == CMD_PANNING8 && isS3M)
+			{
+				// This needs some manual fixing.
+				if(settings.m_param <= 0x80)
+				{
+					// Can't have surround in volume column, only normal panning
+					newVolCmd = VOLCMD_PANNING;
+					newVol /= 2u;
+				}
+			} else
+			{
+				newVolCmd = settings.m_command;
+				if(!ModCommand::ConvertVolEffect(newVolCmd, newVol, true))
+				{
+					// No Success :(
+					newVolCmd = VOLCMD_NONE;
+				}
+			}
+
+			if(newVolCmd != CMD_NONE)
+			{
+				settings.m_volcmd = static_cast<VolumeCommand>(newVolCmd);
+				settings.m_vol = newVol;
+				settings.m_retry = false;
+			}
+		}
+
+		if(!settings.m_retry)
+		{
+			settings.m_isVolEffect = !settings.m_isVolEffect;
+			if(WriteEffect(settings))
+			{
+				return true;
+			}
+		}
+	}
+
+	// Try in the next row if possible (this may also happen if we already retried)
+	if(settings.m_retryMode == EffectWriter::rmTryNextRow && settings.m_row + 1 < GetNumRows())
+	{
+		settings.m_row++;
+		settings.m_retry = true;
+		return WriteEffect(settings);
+	} else if(settings.m_retryMode == EffectWriter::rmTryPreviousRow && settings.m_row > 0)
+	{
+		settings.m_row--;
+		settings.m_retry = true;
+		return WriteEffect(settings);
+	}
+
+	return false;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+//
+//	Pattern serialization functions
+//
+////////////////////////////////////////////////////////////////////////
+
+
+enum maskbits
+{
+	noteBit			= (1 << 0),
+	instrBit		= (1 << 1),
+	volcmdBit		= (1 << 2),
+	volBit			= (1 << 3),
+	commandBit		= (1 << 4),
+	effectParamBit	= (1 << 5),
+	extraData		= (1 << 6)
+};
+
+void WriteData(std::ostream& oStrm, const CPattern& pat);
+void ReadData(std::istream& iStrm, CPattern& pat, const size_t nSize = 0);
+
+void WriteModPattern(std::ostream& oStrm, const CPattern& pat)
+{
+	srlztn::SsbWrite ssb(oStrm);
+	ssb.BeginWrite(FileIdPattern, Version::Current().GetRawVersion());
+	ssb.WriteItem(pat, "data", &WriteData);
+	// pattern time signature
+	if(pat.GetOverrideSignature())
+	{
+		ssb.WriteItem<uint32>(pat.GetRowsPerBeat(), "RPB.");
+		ssb.WriteItem<uint32>(pat.GetRowsPerMeasure(), "RPM.");
+	}
+	if(pat.HasTempoSwing())
+	{
+		ssb.WriteItem<TempoSwing>(pat.GetTempoSwing(), "SWNG", TempoSwing::Serialize);
+	}
+	ssb.FinishWrite();
+}
+
+
+void ReadModPattern(std::istream& iStrm, CPattern& pat, const size_t)
+{
+	srlztn::SsbRead ssb(iStrm);
+	ssb.BeginRead(FileIdPattern, Version::Current().GetRawVersion());
+	if ((ssb.GetStatus() & srlztn::SNT_FAILURE) != 0)
+		return;
+	ssb.ReadItem(pat, "data", &ReadData);
+	// pattern time signature
+	uint32 rpb = 0, rpm = 0;
+	ssb.ReadItem<uint32>(rpb, "RPB.");
+	ssb.ReadItem<uint32>(rpm, "RPM.");
+	pat.SetSignature(rpb, rpm);
+	TempoSwing swing;
+	ssb.ReadItem<TempoSwing>(swing, "SWNG", TempoSwing::Deserialize);
+	if(!swing.empty())
+		swing.resize(pat.GetRowsPerBeat());
+	pat.SetTempoSwing(swing);
+}
+
+
+static uint8 CreateDiffMask(const ModCommand &chnMC, const ModCommand &newMC)
+{
+	uint8 mask = 0;
+	if(chnMC.note != newMC.note)
+		mask |= noteBit;
+	if(chnMC.instr != newMC.instr)
+		mask |= instrBit;
+	if(chnMC.volcmd != newMC.volcmd)
+		mask |= volcmdBit;
+	if(chnMC.vol != newMC.vol)
+		mask |= volBit;
+	if(chnMC.command != newMC.command)
+		mask |= commandBit;
+	if(chnMC.param != newMC.param)
+		mask |= effectParamBit;
+	return mask;
+}
+
+
+// Writes pattern data. Adapted from SaveIT.
+void WriteData(std::ostream& oStrm, const CPattern& pat)
+{
+	if(!pat.IsValid())
+		return;
+
+	const ROWINDEX rows = pat.GetNumRows();
+	const CHANNELINDEX chns = pat.GetNumChannels();
+	std::vector<ModCommand> lastChnMC(chns);
+
+	for(ROWINDEX r = 0; r<rows; r++)
+	{
+		for(CHANNELINDEX c = 0; c<chns; c++)
+		{
+			const ModCommand m = *pat.GetpModCommand(r, c);
+			// Writing only commands not written in IT-pattern writing:
+			// For now this means only NOTE_PC and NOTE_PCS.
+			if(!m.IsPcNote())
+				continue;
+			uint8 diffmask = CreateDiffMask(lastChnMC[c], m);
+			uint8 chval = static_cast<uint8>(c+1);
+			if(diffmask != 0)
+				chval |= IT_bitmask_patternChanEnabled_c;
+
+			mpt::IO::WriteIntLE<uint8>(oStrm, chval);
+
+			if(diffmask)
+			{
+				lastChnMC[c] = m;
+				mpt::IO::WriteIntLE<uint8>(oStrm, diffmask);
+				if(diffmask & noteBit) mpt::IO::WriteIntLE<uint8>(oStrm, m.note);
+				if(diffmask & instrBit) mpt::IO::WriteIntLE<uint8>(oStrm, m.instr);
+				if(diffmask & volcmdBit) mpt::IO::WriteIntLE<uint8>(oStrm, m.volcmd);
+				if(diffmask & volBit) mpt::IO::WriteIntLE<uint8>(oStrm, m.vol);
+				if(diffmask & commandBit) mpt::IO::WriteIntLE<uint8>(oStrm, m.command);
+				if(diffmask & effectParamBit) mpt::IO::WriteIntLE<uint8>(oStrm, m.param);
+			}
+		}
+		mpt::IO::WriteIntLE<uint8>(oStrm, 0); // Write end of row marker.
+	}
+}
+
+
+#define READITEM(itembit,id)		\
+if(diffmask & itembit)				\
+{									\
+	mpt::IO::ReadIntLE<uint8>(iStrm, temp);	\
+	if(ch < chns)					\
+		lastChnMC[ch].id = temp;	\
+}									\
+if(ch < chns)						\
+	m.id = lastChnMC[ch].id;
+
+
+void ReadData(std::istream& iStrm, CPattern& pat, const size_t)
+{
+	if (!pat.IsValid()) // Expecting patterns to be allocated and resized properly.
+		return;
+
+	const CHANNELINDEX chns = pat.GetNumChannels();
+	const ROWINDEX rows = pat.GetNumRows();
+
+	std::vector<ModCommand> lastChnMC(chns);
+
+	ROWINDEX row = 0;
+	while(row < rows && iStrm.good())
+	{
+		uint8 t = 0;
+		mpt::IO::ReadIntLE<uint8>(iStrm, t);
+		if(t == 0)
+		{
+			row++;
+			continue;
+		}
+
+		CHANNELINDEX ch = (t & IT_bitmask_patternChanField_c);
+		if(ch > 0)
+			ch--;
+
+		uint8 diffmask = 0;
+		if((t & IT_bitmask_patternChanEnabled_c) != 0)
+			mpt::IO::ReadIntLE<uint8>(iStrm, diffmask);
+		uint8 temp = 0;
+
+		ModCommand dummy = ModCommand::Empty();
+		ModCommand& m = (ch < chns) ? *pat.GetpModCommand(row, ch) : dummy;
+
+		READITEM(noteBit, note);
+		READITEM(instrBit, instr);
+		READITEM(volcmdBit, volcmd);
+		READITEM(volBit, vol);
+		READITEM(commandBit, command);
+		READITEM(effectParamBit, param);
+		if(diffmask & extraData)
+		{
+			//Ignore additional data.
+			uint8 size;
+			mpt::IO::ReadIntLE<uint8>(iStrm, size);
+			iStrm.ignore(size);
+		}
+	}
+}
+
+#undef READITEM
+
+
+OPENMPT_NAMESPACE_END