405 lines
11 KiB
C++
405 lines
11 KiB
C++
/**
|
|
* Furnace Tracker - multi-system chiptune tracker
|
|
* Copyright (C) 2021-2024 tildearrow and contributors
|
|
*
|
|
* 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 2 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, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#include "fileOpsCommon.h"
|
|
|
|
class TFMRLEReader;
|
|
|
|
struct TFMEndOfFileException {
|
|
TFMRLEReader* reader;
|
|
size_t finalSize;
|
|
TFMEndOfFileException(TFMRLEReader* r, size_t fs):
|
|
reader(r),
|
|
finalSize(fs) {}
|
|
};
|
|
|
|
|
|
class TFMRLEReader {
|
|
const unsigned char* buf;
|
|
size_t len;
|
|
size_t curSeek;
|
|
bool inTag;
|
|
int tagLenLeft;
|
|
char tagChar;
|
|
|
|
void decodeRLE(char prevChar) {
|
|
int lenShift=0;
|
|
tagLenLeft=0;
|
|
char rleTag=0;
|
|
do {
|
|
rleTag=readC();
|
|
tagLenLeft|=(rleTag&0x7F)<<lenShift;
|
|
lenShift+=7;
|
|
logD("RLE tag: %X, len shift: %d, len left: %d",rleTag,lenShift,tagLenLeft);
|
|
} while (!(rleTag&0x80));
|
|
// sync back since we've already read one character
|
|
tagLenLeft--;
|
|
inTag=true;
|
|
tagChar=prevChar;
|
|
}
|
|
|
|
public:
|
|
TFMRLEReader(const void* b, size_t l) :
|
|
buf((const unsigned char*)b),
|
|
len(l),
|
|
curSeek(0),
|
|
inTag(false),
|
|
tagLenLeft(0),
|
|
tagChar(0) {}
|
|
|
|
// these functions may throw TFMEndOfFileException
|
|
unsigned char readC() {
|
|
if (inTag) {
|
|
if (!tagLenLeft) {
|
|
inTag=false;
|
|
return readC();
|
|
}
|
|
tagLenLeft--;
|
|
logD("one char RLE decompressed, tag left: %d, char: %d",tagLenLeft,tagChar);
|
|
return tagChar;
|
|
}
|
|
if (curSeek>len) throw TFMEndOfFileException(this,len);
|
|
|
|
unsigned char ret=buf[curSeek++];
|
|
|
|
// MISLEADING DOCUMENTATION: while TFM music maker's documentation says if the next byte
|
|
// is zero, then it's not a tag but just 0x80 (for example: 0x00 0x80 0x00 = 0x00 0x80)
|
|
// this is actually wrong
|
|
// through research and experimentation, there are times that TFM music maker
|
|
// will use 0x80 0x00 for actual tags (for example: 0x00 0x80 0x00 0x84 = 512 times 0x00
|
|
// in certain parts of the header and footer)
|
|
// TFM music maker actually uses double 0x80 to escape the 0x80
|
|
// for example: 0xDA 0x80 0x80 0x00 0x23 = 0xDA 0x80 0x00 0x23)
|
|
if (ret==0x80 && curSeek+1<len) {
|
|
if (buf[curSeek+1]!=0x80) {
|
|
decodeRLE(buf[curSeek-2]);
|
|
tagLenLeft--;
|
|
return tagChar;
|
|
} else {
|
|
// to avoid outputting the extra 0x80
|
|
curSeek++;
|
|
return ret;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
char readCNoRLE() {
|
|
if (curSeek+1>len) throw TFMEndOfFileException(this,len);
|
|
return buf[curSeek++];
|
|
}
|
|
|
|
void read(unsigned char* b, size_t l) {
|
|
int i=0;
|
|
while(l--) {
|
|
unsigned char nextChar=readC();
|
|
b[i++]=nextChar;
|
|
logD("read next char: %x, index: %d",nextChar,i);
|
|
}
|
|
}
|
|
|
|
void readNoRLE(unsigned char *b, size_t l) {
|
|
int i=0;
|
|
while (l--) {
|
|
b[i++]=buf[curSeek++];
|
|
if (curSeek>len) throw TFMEndOfFileException(this,len);
|
|
}
|
|
}
|
|
|
|
short readS() {
|
|
return readC()|readC()<<8;
|
|
}
|
|
|
|
short readSNoRLE() {
|
|
if (curSeek+2>len) throw TFMEndOfFileException(this,len);
|
|
short ret=buf[curSeek]|buf[curSeek+1]<<8;
|
|
curSeek+=2;
|
|
return ret;
|
|
}
|
|
|
|
void skip(size_t l) {
|
|
// quick and dirty
|
|
while (l--) {
|
|
logD("skipping l %d", l);
|
|
readC();
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
String TFMparseDate(short date) {
|
|
return fmt::sprintf("%02d.%02d.%02d",date>>11,(date>>7)&0xF,date&0x7F);
|
|
}
|
|
|
|
bool DivEngine::loadTFM(unsigned char* file, size_t len) {
|
|
struct InvalidHeaderException {};
|
|
bool success=false;
|
|
TFMRLEReader reader=TFMRLEReader(file,len);
|
|
|
|
try {
|
|
DivSong ds;
|
|
ds.systemName="Sega Genesis/Mega Drive or TurboSound FM";
|
|
ds.subsong[0]->hz=50;
|
|
ds.systemLen = 1;
|
|
|
|
ds.system[0]=DIV_SYSTEM_YM2608;
|
|
unsigned char magic[8]={0};
|
|
|
|
reader.readNoRLE(magic, 8);
|
|
if (memcmp(magic,DIV_TFM_MAGIC,8)!=0) throw InvalidHeaderException();
|
|
|
|
unsigned char speedEven=reader.readCNoRLE();
|
|
unsigned char speedOdd=reader.readCNoRLE();
|
|
unsigned char interleaveFactor=reader.readCNoRLE();
|
|
|
|
// TODO: due to limitations with the groove pattern, only interleave factors up to 8
|
|
// are allowed in furnace
|
|
if (interleaveFactor>8) {
|
|
logW("interleave factor is bigger than 8, speed information may be inaccurate");
|
|
interleaveFactor=8;
|
|
}
|
|
|
|
if (speedEven==speedOdd) {
|
|
ds.subsong[0]->speeds.val[0]=speedEven;
|
|
ds.subsong[0]->speeds.len=1;
|
|
} else {
|
|
for (int i=0; i<interleaveFactor; i++) {
|
|
ds.subsong[0]->speeds.val[i]=speedEven;
|
|
ds.subsong[0]->speeds.val[i+interleaveFactor]=speedOdd;
|
|
}
|
|
ds.subsong[0]->speeds.len=interleaveFactor*2;
|
|
}
|
|
ds.subsong[0]->ordersLen=reader.readCNoRLE();
|
|
|
|
// order loop position, unused
|
|
(void)reader.readCNoRLE();
|
|
|
|
ds.createdDate=TFMparseDate(reader.readSNoRLE());
|
|
ds.revisionDate=TFMparseDate(reader.readSNoRLE());
|
|
|
|
// TODO: use this for something, number of saves
|
|
(void)reader.readSNoRLE();
|
|
|
|
unsigned char buffer[384];
|
|
|
|
// author
|
|
logD("parsing author");
|
|
reader.read(buffer,64);
|
|
ds.author=String((const char*)buffer,strnlen((const char*)buffer,64));
|
|
memset(buffer, 0, 64);
|
|
|
|
// name
|
|
logD("parsing name");
|
|
reader.read(buffer,64);
|
|
ds.name=String((const char*)buffer,strnlen((const char*)buffer,64));
|
|
memset(buffer, 0, 64);
|
|
|
|
// notes
|
|
logD("parsing notes");
|
|
reader.read(buffer,384);
|
|
String notes((const char*)buffer,strnlen((const char*)buffer,384));
|
|
|
|
// fix \r\n to \n
|
|
for (auto& c : notes) {
|
|
if (c=='\r') {
|
|
notes.erase(c,1);
|
|
}
|
|
}
|
|
|
|
// order list
|
|
logD("parsing order list");
|
|
unsigned char orderList[256];
|
|
reader.read(orderList,256);
|
|
|
|
bool patExists[256];
|
|
unsigned char maxPat=0;
|
|
for (int i=0; i<ds.subsong[0]->ordersLen; i++) {
|
|
patExists[orderList[i]]=true;
|
|
if (maxPat<orderList[i]) maxPat=orderList[i];
|
|
|
|
for (int j=0; j<6; j++) {
|
|
ds.subsong[0]->orders.ord[j][i]=orderList[i];
|
|
ds.subsong[0]->pat[j].data[orderList[i]]=new DivPattern;
|
|
}
|
|
}
|
|
|
|
DivInstrument* insMaps[256];
|
|
int insNumMaps[256];
|
|
|
|
// instrument names
|
|
logD("parsing instruments");
|
|
unsigned char insName[16];
|
|
int insCount=0;
|
|
for (int i=0; i<255; i++) {
|
|
reader.read(insName,16);
|
|
|
|
if (memcmp(insName,"\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF",16)==0) {
|
|
logD("instrument unused");
|
|
insNumMaps[i]=i;
|
|
insMaps[i]=NULL;
|
|
continue;
|
|
}
|
|
|
|
DivInstrument* ins=new DivInstrument;
|
|
ins->type=DIV_INS_FM;
|
|
ins->name=String((const char*)insName,strnlen((const char*)insName,16));
|
|
ds.ins.push_back(ins);
|
|
|
|
insNumMaps[i]=insCount;
|
|
insCount++;
|
|
|
|
insMaps[i]=ins;
|
|
}
|
|
|
|
ds.insLen=insCount;
|
|
|
|
// instrument data
|
|
for (int i=0; i<255; i++) {
|
|
if (!insMaps[i]) {
|
|
reader.skip(42);
|
|
continue;
|
|
}
|
|
|
|
insMaps[i]->fm.alg=reader.readC();
|
|
insMaps[i]->fm.fb=reader.readC();
|
|
|
|
for (int j=0; j<4; j++) {
|
|
insMaps[i]->fm.op[j].mult=reader.readC();
|
|
insMaps[i]->fm.op[j].dt=reader.readC();
|
|
insMaps[i]->fm.op[j].tl=reader.readC()^0x7F;
|
|
insMaps[i]->fm.op[j].rs=reader.readC();
|
|
insMaps[i]->fm.op[j].ar=reader.readC()^0x1F;
|
|
insMaps[i]->fm.op[j].dr=reader.readC()^0x1F;
|
|
insMaps[i]->fm.op[j].d2r=reader.readC()^0x1F;
|
|
insMaps[i]->fm.op[j].rr=reader.readC()^0xF;
|
|
insMaps[i]->fm.op[j].sl=reader.readC();
|
|
insMaps[i]->fm.op[j].ssgEnv=reader.readC();
|
|
}
|
|
}
|
|
|
|
ds.notes=notes;
|
|
|
|
unsigned char patLens[256];
|
|
int maxPatLen=0;
|
|
reader.read(patLens, 256);
|
|
for (int i=0;i<256;i++) {
|
|
if (patLens[i]==0) {
|
|
maxPatLen=256;
|
|
break;
|
|
} else if (patLens[i]>maxPatLen) {
|
|
maxPatLen=patLens[i];
|
|
}
|
|
}
|
|
|
|
ds.subsong[0]->patLen=maxPatLen;
|
|
|
|
// PATTERN DATA FORMAT (not described properly in the documentation)
|
|
// for each channel in a pattern:
|
|
// - note data (256 bytes)
|
|
// - volume data (256 bytes, values always 0x00-0x1F)
|
|
// - instrument number data (256 bytes)
|
|
// - effect number (256 bytes, values 0x0-0x23 (to represent 0-F and G-Z))
|
|
// - effect value (256 bytes)
|
|
// - padding(?) (1536 bytes, always set to 0)
|
|
// notes are stored as an inverted value of note+octave*12
|
|
// key-offs are stored in the note data as 0x01
|
|
unsigned char patDataBuf[256];
|
|
|
|
for (int i=0; i<256; i++) {
|
|
if (i>maxPat) break;
|
|
else if (!patExists[i]) {
|
|
logD("skipping pattern %d", i);
|
|
reader.skip(16896);
|
|
continue;
|
|
}
|
|
|
|
logD("parsing pattern %d", i);
|
|
for (int j=0; j<6; j++) {
|
|
DivPattern* pat = ds.subsong[0]->pat[j].data[i];
|
|
|
|
// notes
|
|
reader.read(patDataBuf, 256);
|
|
|
|
logD("parsing notes of pattern %d channel %d", i, j);
|
|
for (int k=0; k<256; k++) {
|
|
if (patDataBuf[k]==0) continue;
|
|
else if (patDataBuf[k]==1) {
|
|
// note off
|
|
pat->data[k][0]=100;
|
|
} else {
|
|
unsigned char invertedNote=~patDataBuf[k];
|
|
pat->data[k][0]=invertedNote%12;
|
|
pat->data[k][1]=(invertedNote/12)-1;
|
|
}
|
|
}
|
|
|
|
// volume
|
|
reader.read(patDataBuf, 256);
|
|
|
|
logD("parsing volumes of pattern %d channel %d", i, j);
|
|
for (int k=0; k<256; k++) {
|
|
if (patDataBuf[k]==0) continue;
|
|
else pat->data[k][3]=patDataBuf[k]*4;
|
|
}
|
|
|
|
// instrument
|
|
reader.read(patDataBuf, 256);
|
|
|
|
logD("parsing instruments of pattern %d channel %d", i, j);
|
|
for (int k=0; k<256; k++) {
|
|
if (patDataBuf[k]==0) continue;
|
|
else {
|
|
pat->data[k][2]=insNumMaps[patDataBuf[k]-1];
|
|
}
|
|
}
|
|
|
|
logD("ignoring unused data of pattern %d channel %d", i, j);
|
|
reader.read(patDataBuf, 256);
|
|
reader.read(patDataBuf, 256);
|
|
|
|
reader.skip(1536);
|
|
}
|
|
|
|
}
|
|
if (active) quitDispatch();
|
|
BUSY_BEGIN_SOFT;
|
|
saveLock.lock();
|
|
song.unload();
|
|
song=ds;
|
|
changeSong(0);
|
|
recalcChans();
|
|
saveLock.unlock();
|
|
BUSY_END;
|
|
if (active) {
|
|
initDispatch();
|
|
BUSY_BEGIN;
|
|
renderSamples();
|
|
reset();
|
|
BUSY_END;
|
|
}
|
|
success=true;
|
|
} catch(TFMEndOfFileException& e) {
|
|
lastError="incomplete file!";
|
|
} catch(InvalidHeaderException& e) {
|
|
lastError="invalid info header!";
|
|
}
|
|
|
|
return success;
|
|
}
|