Initial commit

engines/chewy/audio/module_tmf.cpp

@@ -0,0 +1,144 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "chewy/audio/module_tmf.h"
+
+#include "common/array.h"
+#include "common/stream.h"
+
+const uint8 Chewy::Module_TMF::TMF_MOD_SONG_NAME[] = {
+	'S', 'C', 'U', 'M', 'M',
+	'V', 'M', ' ', 'M', 'O',
+	'D', 'U', 'L', 'E', '\0',
+	'\0', '\0', '\0', '\0', '\0', '\0'
+};
+const uint8 Chewy::Module_TMF::TMF_MOD_INSTRUMENT_NAME[] = {
+	'S', 'C', 'U', 'M', 'M',
+	'V', 'M', ' ', 'I', 'N',
+	'S', 'T', 'R', 'U', 'M',
+	'E', 'N', 'T', ' ', '\0',
+	'\0', '\0', '\0'
+};
+const uint16 Chewy::Module_TMF::TMF_MOD_PERIODS[] = {
+	856, 808, 762, 720, 678, 640, 604, 570, 538, 508, 480, 453,
+	428, 404, 381, 360, 339, 320, 302, 285, 269, 254, 240, 226,
+	214, 202, 190, 180, 170, 160, 151, 143, 135, 127, 120, 113
+};
+
+bool Chewy::Module_TMF::load(Common::SeekableReadStream& stream, int offs) {
+	stream.seek(offs);
+
+	// Check TMF fourCC.
+	if (stream.readUint32BE() != MKTAG('T', 'M', 'F', '\0'))
+		error("Corrupt TMF resource");
+
+	// Write song name (not present in TMF data).
+	Common::copy(TMF_MOD_SONG_NAME, TMF_MOD_SONG_NAME + 21, songname);
+
+	// Copy instrument data.
+	uint8 fineTune, instVolume;
+	uint32 repeatPoint, repeatLength, sampleLength;
+	//uint32 totalSampleLength = 0;
+
+	for (int i = 0; i < NUM_SAMPLES; ++i) {
+		fineTune = stream.readByte();
+		instVolume = stream.readByte();
+		// Repeat point, repeat length and sample length are 32 bit LE in bytes
+		// instead of 16 bit BE in words.
+		repeatPoint = stream.readUint32LE();
+		assert(repeatPoint <= 0x1FFFF && repeatPoint % 2 == 0);
+		repeatLength = stream.readUint32LE();
+		assert(repeatLength <= 0x1FFFF && repeatLength % 2 == 0);
+		// Sample length is at the end instead of at the start.
+		sampleLength = stream.readUint32LE();
+		assert(sampleLength <= 0x1FFFF && sampleLength % 2 == 0);
+		//totalSampleLength += sampleLength;
+
+		// Instrument name is not present in TMF data.
+		Common::copy(TMF_MOD_INSTRUMENT_NAME, TMF_MOD_INSTRUMENT_NAME + 23, sample[i].name);
+		sample[i].name[19] = '0' + i / 10;
+		sample[i].name[20] = '0' + i % 10;
+
+		sample[i].len = sampleLength;
+		// Finetune is a signed nibble in MOD, but TMF uses a signed byte
+		// (within nibble range).
+		sample[i].finetune = fineTune & 0x0F;
+		sample[i].vol = instVolume;
+		sample[i].repeat = repeatPoint;
+		sample[i].replen = repeatLength;
+	}
+
+	// Copy pattern table.
+	songlen = stream.readByte();
+	// Second byte is the number of different patterns in TMF. This byte is
+	// unused in MOD (usually set to 0x7F).
+	uint8 numPatterns = stream.readByte();
+	undef = 0x7F;
+	stream.read(songpos, 128);
+	// M.K. fourCC is not present in TMF.
+	sig = signatures[0];
+
+	// TMF has a 32 bit LE number for each instrument here; these are probably
+	// offsets for each sample. They are not present in MOD and not needed, so
+	// they are skipped.
+	stream.skip(4 * 31);
+
+	// Copy pattern data.
+	pattern = new Modules::pattern_t[numPatterns];
+	for (int i = 0; i < numPatterns; ++i) {
+		for (int j = 0; j < 64; ++j) {
+			for (int k = 0; k < 4; ++k) {
+				// TMF channel data has this format:
+				// 1 byte note (0-0x23 or 0x30 for "use previous value")
+				// 1 byte sample
+				// 2 bytes effect (byte 3 high nibble is unused)
+				byte note = stream.readByte();
+				assert(note == 0x30 || note < 36);
+				byte sampleNum = stream.readByte();
+				uint16 effect = stream.readUint16BE();
+				assert((effect & 0xF000) == 0);
+				// Note is converted to a MOD 12 bit period using a lookup array.
+				uint16 period = note == 0x30 ? 0 : TMF_MOD_PERIODS[note];
+				pattern[i][j][k].sample = sampleNum;
+				pattern[i][j][k].period = period;
+				pattern[i][j][k].effect = effect;
+				pattern[i][j][k].note = periodToNote(period);
+			}
+		}
+	}
+
+	// Copy sample data.
+	for (int i = 0; i < NUM_SAMPLES; ++i) {
+		if (!sample[i].len) {
+			sample[i].data = nullptr;
+		} else {
+			sample[i].data = new int8[sample[i].len];
+			for (int j = 0; j < sample[i].len; j++) {
+				int tmfSample = stream.readByte();
+				// Convert from unsigned to signed.
+				tmfSample -= 0x80;
+				sample[i].data[j] = tmfSample & 0xFF;
+			}
+		}
+	}
+
+	return true;
+}