etc
/
furnace
mirror of https://github.com/tildearrow/furnace.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fix big-endian build (i think)

This commit is contained in:
tildearrow 2022-08-19 01:26:11 -05:00
parent 142c21e20b
commit 5c7338930f
2 changed files with 113 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
src/engine/fileOps.cpp
View File

@ -825,6 +825,13 @@ bool DivEngine::loadDMF(unsigned char* file, size_t len) {
data=new short[length];
reader.read(data,length*2);
}
#ifdef TA_BIG_ENDIAN
// convert to big-endian
for (size_t pos=0; pos<length; pos++) {
data[pos]=(short)((((unsigned short)data[pos])<<8)|(((unsigned short)data[pos])>>8));
}
#endif
if (pitch!=5) {
logD("%d: scaling from %d...",i,pitch);
@ -1323,9 +1330,15 @@ bool DivEngine::loadFur(unsigned char* file, size_t len) {
}
// pointers
reader.read(insPtr,ds.insLen*4);
reader.read(wavePtr,ds.waveLen*4);
reader.read(samplePtr,ds.sampleLen*4);
for (int i=0; i<ds.insLen; i++) {
insPtr[i]=reader.readI();
}
for (int i=0; i<ds.waveLen; i++) {
wavePtr[i]=reader.readI();
}
for (int i=0; i<ds.sampleLen; i++) {
samplePtr[i]=reader.readI();
}
for (int i=0; i<numberOfPats; i++) patPtr.push_back(reader.readI());
logD("reading orders (%d)...",subSong->ordersLen);
@ -1703,11 +1716,36 @@ bool DivEngine::loadFur(unsigned char* file, size_t len) {
if (ds.version>=58) { // modern sample
sample->init(sample->samples);
reader.read(sample->getCurBuf(),sample->getCurBufLen());
#ifdef TA_BIG_ENDIAN
// convert 16-bit samples to big-endian
if (sample->depth==DIV_SAMPLE_DEPTH_16BIT) {
unsigned char* sampleBuf=sample->getCurBuf();
size_t sampleBufLen=sample->getCurBufLen();
for (size_t pos=0; pos<sampleBufLen; pos+=2) {
sampleBuf[pos]^=sampleBuf[pos+1];
sampleBuf[pos+1]^=sampleBuf[pos];
sampleBuf[pos]^=sampleBuf[pos+1];
}
}
#endif
} else { // legacy sample
int length=sample->samples;
short* data=new short[length];
reader.read(data,2*length);
#ifdef TA_BIG_ENDIAN
// convert 16-bit samples to big-endian
if (sample->depth==DIV_SAMPLE_DEPTH_16BIT) {
unsigned char* sampleBuf=sample->getCurBuf();
size_t sampleBufLen=sample->getCurBufLen();
for (size_t pos=0; pos<sampleBufLen; pos+=2) {
sampleBuf[pos]^=sampleBuf[pos+1];
sampleBuf[pos+1]^=sampleBuf[pos];
sampleBuf[pos]^=sampleBuf[pos+1];
}
}
#endif
if (pitch!=5) {
logD("%d: scaling from %d...",i,pitch);
}
@ -3807,7 +3845,21 @@ SafeWriter* DivEngine::saveFur(bool notPrimary) {
w->writeI(0xffffffff);
}
#ifdef TA_BIG_ENDIAN
// store 16-bit samples as little-endian
if (sample->depth==DIV_SAMPLE_DEPTH_16BIT) {
unsigned char* sampleBuf=(unsigned char*)sample->getCurBuf();
size_t bufLen=sample->getCurBufLen();
for (size_t i=0; i<bufLen; i+=2) {
w->writeC(sampleBuf[i+1]);
w->writeC(sampleBuf[i]);
}
} else {
w->write(sample->getCurBuf(),sample->getCurBufLen());
}
#else
w->write(sample->getCurBuf(),sample->getCurBufLen());
#endif
blockEndSeek=w->tell();
w->seek(blockStartSeek,SEEK_SET);
@ -3834,7 +3886,13 @@ SafeWriter* DivEngine::saveFur(bool notPrimary) {
w->writeS(pat->data[j][1]); // octave
w->writeS(pat->data[j][2]); // instrument
w->writeS(pat->data[j][3]); // volume
#ifdef TA_BIG_ENDIAN
for (int k=0; k<song.subsong[i.subsong]->pat[i.chan].effectCols*2; k++) {
w->writeS(pat->data[j][4+k]);
}
#else
w->write(&pat->data[j][4],2*song.subsong[i.subsong]->pat[i.chan].effectCols*2); // effects
#endif
}
w->writeString(pat->name,false);
@ -4116,7 +4174,9 @@ SafeWriter* DivEngine::saveDMF(unsigned char version) {
w->writeI(i->std.volMacro.val[j]+18);
}
} else {
w->write(i->std.volMacro.val,4*i->std.volMacro.len);
for (int j=0; j<i->std.volMacro.len; j++) {
w->writeI(i->std.volMacro.val[j]);
}
}
if (i->std.volMacro.len>0) {
w->writeC(i->std.volMacro.loop);
@ -4125,7 +4185,9 @@ SafeWriter* DivEngine::saveDMF(unsigned char version) {
w->writeC(i->std.arpMacro.len);
if (i->std.arpMacro.mode) {
w->write(i->std.arpMacro.val,4*i->std.arpMacro.len);
for (int j=0; j<i->std.arpMacro.len; j++) {
w->writeI(i->std.arpMacro.val[j]);
}
} else {
for (int j=0; j<i->std.arpMacro.len; j++) {
w->writeI(i->std.arpMacro.val[j]+12);
@ -4142,14 +4204,18 @@ SafeWriter* DivEngine::saveDMF(unsigned char version) {
w->writeI(i->std.dutyMacro.val[j]+12);
}
} else {
w->write(i->std.dutyMacro.val,4*i->std.dutyMacro.len);
for (int j=0; j<i->std.dutyMacro.len; j++) {
w->writeI(i->std.dutyMacro.val[j]);
}
}
if (i->std.dutyMacro.len>0) {
w->writeC(i->std.dutyMacro.loop);
}
w->writeC(i->std.waveMacro.len);
w->write(i->std.waveMacro.val,4*i->std.waveMacro.len);
for (int j=0; j<i->std.waveMacro.len; j++) {
w->writeI(i->std.waveMacro.val[j]);
}
if (i->std.waveMacro.len>0) {
w->writeC(i->std.waveMacro.loop);
}
@ -4200,7 +4266,9 @@ SafeWriter* DivEngine::saveDMF(unsigned char version) {
w->writeI(i->data[j]>>2);
}
} else {
w->write(i->data,4*i->len);
for (int j=0; j<i->len; j++) {
w->writeI(i->data[j]);
}
}
}
@ -4213,7 +4281,13 @@ SafeWriter* DivEngine::saveDMF(unsigned char version) {
w->writeS(pat->data[k][0]); // note
w->writeS(pat->data[k][1]); // octave
w->writeS(pat->data[k][3]); // volume
#ifdef TA_BIG_ENDIAN
for (int l=0; l<curPat[i].effectCols*2; l++) {
w->writeS(pat->data[k][4+l]);
}
#else
w->write(&pat->data[k][4],2*curPat[i].effectCols*2); // effects
#endif
w->writeS(pat->data[k][2]); // instrument
}
}
@ -4232,7 +4306,15 @@ SafeWriter* DivEngine::saveDMF(unsigned char version) {
w->writeC(50);
// i'm too lazy to deal with .dmf's weird way of storing 8-bit samples
w->writeC(16);
// well I can't be lazy if it's on a big-endian system
#ifdef TA_BIG_ENDIAN
for (unsigned int j=0; j<i->length16; j++) {
w->writeC(((unsigned short)i->data16[j])&0xff);
w->writeC(((unsigned short)i->data16[j])>>8);
}
#else
w->write(i->data16,i->length16);
#endif
}
saveLock.unlock();

43
src/engine/instrument.cpp
View File

@ -549,6 +549,9 @@ void DivInstrument::putInsData(SafeWriter* w) {
w->seek(0,SEEK_END);
}
#define READ_MACRO_VALS(x,y) \
for (int macroValPos=0; macroValPos<y; macroValPos++) x[macroValPos]=reader.readI();
DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
char magic[4];
reader.read(magic,4);
@ -674,10 +677,10 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
int oldVolHeight=reader.readC();
int oldDutyHeight=reader.readC();
reader.readC(); // oldWaveHeight
reader.read(std.volMacro.val,4*std.volMacro.len);
reader.read(std.arpMacro.val,4*std.arpMacro.len);
reader.read(std.dutyMacro.val,4*std.dutyMacro.len);
reader.read(std.waveMacro.val,4*std.waveMacro.len);
READ_MACRO_VALS(std.volMacro.val,std.volMacro.len);
READ_MACRO_VALS(std.arpMacro.val,std.arpMacro.len);
READ_MACRO_VALS(std.dutyMacro.val,std.dutyMacro.len);
READ_MACRO_VALS(std.waveMacro.val,std.waveMacro.len);
if (version<31) {
if (!std.arpMacro.mode) for (int j=0; j<std.arpMacro.len; j++) {
std.arpMacro.val[j]-=12;
@ -692,10 +695,10 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
}
}
if (version>=17) {
reader.read(std.pitchMacro.val,4*std.pitchMacro.len);
reader.read(std.ex1Macro.val,4*std.ex1Macro.len);
reader.read(std.ex2Macro.val,4*std.ex2Macro.len);
reader.read(std.ex3Macro.val,4*std.ex3Macro.len);
READ_MACRO_VALS(std.pitchMacro.val,std.pitchMacro.len);
READ_MACRO_VALS(std.ex1Macro.val,std.ex1Macro.len);
READ_MACRO_VALS(std.ex2Macro.val,std.ex2Macro.len);
READ_MACRO_VALS(std.ex3Macro.val,std.ex3Macro.len);
} else {
if (type==DIV_INS_STD) {
if (oldVolHeight==31) {
@ -730,10 +733,10 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
std.fmsMacro.open=reader.readC();
std.amsMacro.open=reader.readC();
reader.read(std.algMacro.val,4*std.algMacro.len);
reader.read(std.fbMacro.val,4*std.fbMacro.len);
reader.read(std.fmsMacro.val,4*std.fmsMacro.len);
reader.read(std.amsMacro.val,4*std.amsMacro.len);
READ_MACRO_VALS(std.algMacro.val,std.algMacro.len);
READ_MACRO_VALS(std.fbMacro.val,std.fbMacro.len);
READ_MACRO_VALS(std.fmsMacro.val,std.fmsMacro.len);
READ_MACRO_VALS(std.amsMacro.val,std.amsMacro.len);
for (int i=0; i<4; i++) {
DivInstrumentSTD::OpMacro& op=std.opMacros[i];
@ -1007,14 +1010,14 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
std.ex7Macro.open=reader.readC();
std.ex8Macro.open=reader.readC();
reader.read(std.panLMacro.val,4*std.panLMacro.len);
reader.read(std.panRMacro.val,4*std.panRMacro.len);
reader.read(std.phaseResetMacro.val,4*std.phaseResetMacro.len);
reader.read(std.ex4Macro.val,4*std.ex4Macro.len);
reader.read(std.ex5Macro.val,4*std.ex5Macro.len);
reader.read(std.ex6Macro.val,4*std.ex6Macro.len);
reader.read(std.ex7Macro.val,4*std.ex7Macro.len);
reader.read(std.ex8Macro.val,4*std.ex8Macro.len);
READ_MACRO_VALS(std.panLMacro.val,std.panLMacro.len);
READ_MACRO_VALS(std.panRMacro.val,std.panRMacro.len);
READ_MACRO_VALS(std.phaseResetMacro.val,std.phaseResetMacro.len);
READ_MACRO_VALS(std.ex4Macro.val,std.ex4Macro.len);
READ_MACRO_VALS(std.ex5Macro.val,std.ex5Macro.len);
READ_MACRO_VALS(std.ex6Macro.val,std.ex6Macro.len);
READ_MACRO_VALS(std.ex7Macro.val,std.ex7Macro.len);
READ_MACRO_VALS(std.ex8Macro.val,std.ex8Macro.len);
// FDS
fds.modSpeed=reader.readI();