264 lines
9.1 KiB
C++
264 lines
9.1 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/>.
|
|
*
|
|
*/
|
|
/*
|
|
* VGMTrans (c) 2002-2019
|
|
* Licensed under the zlib license,
|
|
* refer to the included VGMTrans_LICENSE.txt file
|
|
*/
|
|
|
|
#include "common/debug.h"
|
|
#include "common/scummsys.h"
|
|
#include "vab.h"
|
|
#include "psxspu.h"
|
|
|
|
using namespace std;
|
|
|
|
Vab::Vab(RawFile *file, uint32 offset) : VGMInstrSet(file, offset) {}
|
|
|
|
Vab::~Vab() {}
|
|
|
|
bool Vab::GetHeaderInfo() {
|
|
uint32 nEndOffset = GetEndOffset();
|
|
uint32 nMaxLength = nEndOffset - _dwOffset;
|
|
|
|
if (nMaxLength < 0x20) {
|
|
return false;
|
|
}
|
|
|
|
_name = "VAB";
|
|
|
|
VGMHeader *vabHdr = AddHeader(_dwOffset, 0x20, "VAB Header");
|
|
vabHdr->AddSimpleItem(_dwOffset + 0x00, 4, "ID");
|
|
vabHdr->AddSimpleItem(_dwOffset + 0x04, 4, "Version");
|
|
vabHdr->AddSimpleItem(_dwOffset + 0x08, 4, "VAB ID");
|
|
vabHdr->AddSimpleItem(_dwOffset + 0x0c, 4, "Total Size");
|
|
vabHdr->AddSimpleItem(_dwOffset + 0x10, 2, "Reserved");
|
|
vabHdr->AddSimpleItem(_dwOffset + 0x12, 2, "Number of Programs");
|
|
vabHdr->AddSimpleItem(_dwOffset + 0x14, 2, "Number of Tones");
|
|
vabHdr->AddSimpleItem(_dwOffset + 0x16, 2, "Number of VAGs");
|
|
vabHdr->AddSimpleItem(_dwOffset + 0x18, 1, "Master Volume");
|
|
vabHdr->AddSimpleItem(_dwOffset + 0x19, 1, "Master Pan");
|
|
vabHdr->AddSimpleItem(_dwOffset + 0x1a, 1, "Bank Attributes 1");
|
|
vabHdr->AddSimpleItem(_dwOffset + 0x1b, 1, "Bank Attributes 2");
|
|
vabHdr->AddSimpleItem(_dwOffset + 0x1c, 4, "Reserved");
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Vab::GetInstrPointers() {
|
|
uint32 nEndOffset = GetEndOffset();
|
|
|
|
uint32 offProgs = _dwOffset + 0x20;
|
|
uint32 offToneAttrs = offProgs + (16 * 128);
|
|
|
|
uint16 numPrograms = GetShort(_dwOffset + 0x12);
|
|
uint16 numVAGs = GetShort(_dwOffset + 0x16);
|
|
|
|
uint32 offVAGOffsets = offToneAttrs + (32 * 16 * numPrograms);
|
|
|
|
VGMHeader *progsHdr = AddHeader(offProgs, 16 * 128, "Program Table");
|
|
VGMHeader *toneAttrsHdr = AddHeader(offToneAttrs, 32 * 16, "Tone Attributes Table");
|
|
|
|
if (numPrograms > 128) {
|
|
debug("Too many programs %x, offset %x", numPrograms, _dwOffset);
|
|
return false;
|
|
}
|
|
if (numVAGs > 255) {
|
|
debug("Too many VAGs %x, offset %x", numVAGs, _dwOffset);
|
|
return false;
|
|
}
|
|
|
|
// Load each instruments.
|
|
//
|
|
// Rule 1. Valid instrument pointers are not always sequentially located from 0 to (numProgs -
|
|
// 1). Number of tones can be 0. That's an empty instrument. We need to ignore it. See Clock
|
|
// Tower PSF for example.
|
|
//
|
|
// Rule 2. Do not load programs more than number of programs. Even if a program table value is
|
|
// provided. Otherwise an out-of-order access can be caused in Tone Attributes Table. See the
|
|
// swimming event BGM of Aitakute... ~your smiles in my heart~ for example. (github issue #115)
|
|
uint32 numProgramsLoaded = 0;
|
|
for (uint32 progIndex = 0; progIndex < 128 && numProgramsLoaded < numPrograms; progIndex++) {
|
|
uint32 offCurrProg = offProgs + (progIndex * 16);
|
|
uint32 offCurrToneAttrs = offToneAttrs + (uint32) (_aInstrs.size() * 32 * 16);
|
|
|
|
if (offCurrToneAttrs + (32 * 16) > nEndOffset) {
|
|
break;
|
|
}
|
|
|
|
uint8 numTonesPerInstr = GetByte(offCurrProg);
|
|
if (numTonesPerInstr > 32) {
|
|
debug("Program %x contains too many tones (%d)", progIndex, numTonesPerInstr);
|
|
} else if (numTonesPerInstr != 0) {
|
|
VabInstr *newInstr = new VabInstr(this, offCurrToneAttrs, 0x20 * 16, 0, progIndex);
|
|
_aInstrs.push_back(newInstr);
|
|
newInstr->_tones = GetByte(offCurrProg + 0);
|
|
|
|
VGMHeader *progHdr = progsHdr->AddHeader(offCurrProg, 0x10, "Program");
|
|
progHdr->AddSimpleItem(offCurrProg + 0x00, 1, "Number of Tones");
|
|
progHdr->AddSimpleItem(offCurrProg + 0x01, 1, "Volume");
|
|
progHdr->AddSimpleItem(offCurrProg + 0x02, 1, "Priority");
|
|
progHdr->AddSimpleItem(offCurrProg + 0x03, 1, "Mode");
|
|
progHdr->AddSimpleItem(offCurrProg + 0x04, 1, "Pan");
|
|
progHdr->AddSimpleItem(offCurrProg + 0x05, 1, "Reserved");
|
|
progHdr->AddSimpleItem(offCurrProg + 0x06, 2, "Attribute");
|
|
progHdr->AddSimpleItem(offCurrProg + 0x08, 4, "Reserved");
|
|
progHdr->AddSimpleItem(offCurrProg + 0x0c, 4, "Reserved");
|
|
|
|
newInstr->_masterVol = GetByte(offCurrProg + 0x01);
|
|
|
|
toneAttrsHdr->_unLength = offCurrToneAttrs + (32 * 16) - offToneAttrs;
|
|
|
|
numProgramsLoaded++;
|
|
}
|
|
}
|
|
|
|
if ((offVAGOffsets + 2 * 256) <= nEndOffset) {
|
|
char name[256];
|
|
Common::Array<SizeOffsetPair> vagLocations;
|
|
uint32 totalVAGSize = 0;
|
|
VGMHeader *vagOffsetHdr = AddHeader(offVAGOffsets, 2 * 256, "VAG Pointer Table");
|
|
|
|
uint32 vagStartOffset = GetShort(offVAGOffsets) * 8;
|
|
vagOffsetHdr->AddSimpleItem(offVAGOffsets, 2, "VAG Size /8 #0");
|
|
totalVAGSize = vagStartOffset;
|
|
|
|
for (uint32 i = 0; i < numVAGs; i++) {
|
|
uint32 vagOffset;
|
|
uint32 vagSize;
|
|
|
|
if (i == 0) {
|
|
vagOffset = vagStartOffset;
|
|
vagSize = GetShort(offVAGOffsets + (i + 1) * 2) * 8;
|
|
} else {
|
|
vagOffset = vagStartOffset + vagLocations[i - 1].offset + vagLocations[i - 1].size;
|
|
vagSize = GetShort(offVAGOffsets + (i + 1) * 2) * 8;
|
|
}
|
|
|
|
snprintf(name, sizeof(name), "VAG Size /8 #%u", i + 1);
|
|
vagOffsetHdr->AddSimpleItem(offVAGOffsets + (i + 1) * 2, 2, name);
|
|
|
|
if (vagOffset + vagSize <= nEndOffset) {
|
|
vagLocations.push_back(SizeOffsetPair(vagOffset, vagSize));
|
|
totalVAGSize += vagSize;
|
|
} else {
|
|
debug("VAG #%d at %x with size %x) is invalid", i + 1, vagOffset, vagSize);
|
|
}
|
|
}
|
|
_unLength = (offVAGOffsets + 2 * 256) - _dwOffset;
|
|
|
|
// single VAB file?
|
|
uint32 offVAGs = offVAGOffsets + 2 * 256;
|
|
if (_dwOffset == 0 && vagLocations.size() != 0) {
|
|
// load samples as well
|
|
PSXSampColl *newSampColl =
|
|
new PSXSampColl(this, offVAGs, totalVAGSize, vagLocations);
|
|
if (newSampColl->LoadVGMFile()) {
|
|
this->_sampColl = newSampColl;
|
|
} else {
|
|
delete newSampColl;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// ********
|
|
// VabInstr
|
|
// ********
|
|
|
|
VabInstr::VabInstr(VGMInstrSet *instrSet, uint32 offset, uint32 length, uint32 theBank,
|
|
uint32 theInstrNum, const Common::String &name)
|
|
: VGMInstr(instrSet, offset, length, theBank, theInstrNum, name), _tones(0), _masterVol(127) {}
|
|
|
|
VabInstr::~VabInstr() {}
|
|
|
|
bool VabInstr::LoadInstr() {
|
|
int8 numRgns = _tones;
|
|
for (int i = 0; i < numRgns; i++) {
|
|
VabRgn *rgn = new VabRgn(this, _dwOffset + i * 0x20);
|
|
if (!rgn->LoadRgn()) {
|
|
delete rgn;
|
|
return false;
|
|
}
|
|
_aRgns.push_back(rgn);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// ******
|
|
// VabRgn
|
|
// ******
|
|
|
|
VabRgn::VabRgn(VabInstr *instr, uint32 offset) : _ADSR1(0), _ADSR2(0), VGMRgn(instr, offset) {}
|
|
|
|
bool VabRgn::LoadRgn() {
|
|
VabInstr *instr = (VabInstr *) _parInstr;
|
|
_unLength = 0x20;
|
|
|
|
AddGeneralItem(_dwOffset, 1, "Priority");
|
|
AddGeneralItem(_dwOffset + 1, 1, "Mode (use reverb?)");
|
|
AddVolume((GetByte(_dwOffset + 2) * instr->_masterVol) / (127.0 * 127.0), _dwOffset + 2, 1);
|
|
AddPan(GetByte(_dwOffset + 3), _dwOffset + 3);
|
|
AddUnityKey(GetByte(_dwOffset + 4), _dwOffset + 4);
|
|
AddGeneralItem(_dwOffset + 5, 1, "Pitch Tune");
|
|
AddKeyLow(GetByte(_dwOffset + 6), _dwOffset + 6);
|
|
AddKeyHigh(GetByte(_dwOffset + 7), _dwOffset + 7);
|
|
AddGeneralItem(_dwOffset + 8, 1, "Vibrato Width");
|
|
AddGeneralItem(_dwOffset + 9, 1, "Vibrato Time");
|
|
AddGeneralItem(_dwOffset + 10, 1, "Portamento Width");
|
|
AddGeneralItem(_dwOffset + 11, 1, "Portamento Holding Time");
|
|
AddGeneralItem(_dwOffset + 12, 1, "Pitch Bend Min");
|
|
AddGeneralItem(_dwOffset + 13, 1, "Pitch Bend Max");
|
|
AddGeneralItem(_dwOffset + 14, 1, "Reserved");
|
|
AddGeneralItem(_dwOffset + 15, 1, "Reserved");
|
|
AddGeneralItem(_dwOffset + 16, 2, "ADSR1");
|
|
AddGeneralItem(_dwOffset + 18, 2, "ADSR2");
|
|
AddGeneralItem(_dwOffset + 20, 2, "Parent Program");
|
|
AddSampNum(GetShort(_dwOffset + 22) - 1, _dwOffset + 22, 2);
|
|
AddGeneralItem(_dwOffset + 24, 2, "Reserved");
|
|
AddGeneralItem(_dwOffset + 26, 2, "Reserved");
|
|
AddGeneralItem(_dwOffset + 28, 2, "Reserved");
|
|
AddGeneralItem(_dwOffset + 30, 2, "Reserved");
|
|
_ADSR1 = GetShort(_dwOffset + 16);
|
|
_ADSR2 = GetShort(_dwOffset + 18);
|
|
if ((int) _sampNum < 0)
|
|
_sampNum = 0;
|
|
|
|
if (_keyLow > _keyHigh) {
|
|
debug("Low key higher than high key %d > %d (at %x)", _keyLow, _keyHigh, _dwOffset);
|
|
return false;
|
|
}
|
|
|
|
// gocha: AFAIK, the valid range of pitch is 0-127. It must not be negative.
|
|
// If it exceeds 127, driver clips the value and it will become 127. (In Hokuto no Ken, at
|
|
// least) I am not sure if the interpretation of this value depends on a driver or VAB version.
|
|
// The following code takes the byte as signed, since it could be a typical extended
|
|
// implementation.
|
|
int8 ft = (int8) GetByte(_dwOffset + 5);
|
|
double cents = ft * 100.0 / 128.0;
|
|
SetFineTune((int16) cents);
|
|
|
|
PSXConvADSR<VabRgn>(this, _ADSR1, _ADSR2, false);
|
|
return true;
|
|
}
|