145 lines
4.8 KiB
C++
145 lines
4.8 KiB
C++
/* 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;
|
|
}
|