otomatalabs/furnace
7
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

part 2 - finally

Browse source
This commit is contained in:
tildearrow 2022-04-10 16:52:03 -05:00
parent c13358d96f
commit 51207e58ad
7 changed files with 283 additions and 765 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
src/engine/fileOps.cpp
View file

@ -307,12 +307,9 @@ bool DivEngine::loadDMF(unsigned char* file, size_t len) {
if (!ins->mode) { if (!ins->mode) {
ins->type=DIV_INS_AY; ins->type=DIV_INS_AY;
} }
ins->std.dutyMacro.height=31;
ins->std.waveMacro.height=7;
} }
if (ds.system[0]==DIV_SYSTEM_PCE) { if (ds.system[0]==DIV_SYSTEM_PCE) {
ins->type=DIV_INS_PCE; ins->type=DIV_INS_PCE;
ins->std.volMacro.height=31;
} }
if ((ds.system[0]==DIV_SYSTEM_SMS_OPLL || ds.system[0]==DIV_SYSTEM_NES_VRC7) && ins->type==DIV_INS_FM) { if ((ds.system[0]==DIV_SYSTEM_SMS_OPLL || ds.system[0]==DIV_SYSTEM_NES_VRC7) && ins->type==DIV_INS_FM) {
ins->type=DIV_INS_OPLL; ins->type=DIV_INS_OPLL;

863
src/engine/instrument.cpp
View file

@ -23,37 +23,13 @@
#include "../ta-log.h" #include "../ta-log.h"
#include "../fileutils.h" #include "../fileutils.h"
void DivInstrument::putMacroData(DivInstrumentMacro m, SafeWriter* w) {
w->write("MACR",4);
w->writeI(0);
w->writeS(DIV_ENGINE_VERSION);
w->writeS(type);
w->writeC(0);
w->writeString(m.name,false);
w->writeI(m.len);
w->writeI(m.loop);
w->writeI(m.rel);
w->writeI(m.mode);
w->writeC(m.open);
for (int v=0; v<m.len; v++) {
w->writeI(m.val[v]);
w->writeI(0); // reserved
w->writeI(0); // reserved
}
}
void DivInstrument::putInsData(SafeWriter* w) { void DivInstrument::putInsData(SafeWriter* w) {
w->write("INST",4); w->write("INST",4);
w->writeI(0); w->writeI(0);
w->writeS(DIV_ENGINE_VERSION); w->writeS(DIV_ENGINE_VERSION);
w->writeS(type); w->writeC(type);
//w->writeC(type);
w->writeC(0); w->writeC(0);
w->writeString(name,false); w->writeString(name,false);
@ -125,7 +101,7 @@ void DivInstrument::putInsData(SafeWriter* w) {
w->writeC(c64.hp); w->writeC(c64.hp);
w->writeC(c64.ch3off); w->writeC(c64.ch3off);
w->writeS(c64.cut); w->writeS(c64.cut);
//w->writeC(std.dutyMacro.mode); w->writeC(c64.dutyIsAbs);
w->writeC(c64.filterIsAbs); w->writeC(c64.filterIsAbs);
// Amiga // Amiga
@ -135,66 +111,6 @@ void DivInstrument::putInsData(SafeWriter* w) {
} }
// standard // standard
putMacroData(std.volMacro,w);
putMacroData(std.arpMacro,w);
putMacroData(std.dutyMacro,w);
putMacroData(std.waveMacro,w);
putMacroData(std.pitchMacro,w);
putMacroData(std.ex1Macro,w);
putMacroData(std.ex2Macro,w);
putMacroData(std.ex3Macro,w);
putMacroData(std.algMacro,w);
putMacroData(std.fbMacro,w);
putMacroData(std.fmsMacro,w);
putMacroData(std.fms2Macro,w);
putMacroData(std.amsMacro,w);
putMacroData(std.ams2Macro,w);
putMacroData(std.panLMacro,w);
putMacroData(std.panRMacro,w);
putMacroData(std.phaseResetMacro,w);
putMacroData(std.ex4Macro,w);
putMacroData(std.ex5Macro,w);
putMacroData(std.ex6Macro,w);
putMacroData(std.ex7Macro,w);
putMacroData(std.ex8Macro,w);
// FM macros
for (int i=0; i<4; i++) {
DivInstrumentSTD::OpMacro& op=std.opMacros[i];
putMacroData(op.amMacro,w);
putMacroData(op.arMacro,w);
putMacroData(op.drMacro,w);
putMacroData(op.multMacro,w);
putMacroData(op.rrMacro,w);
putMacroData(op.slMacro,w);
putMacroData(op.tlMacro,w);
putMacroData(op.dt2Macro,w);
putMacroData(op.rsMacro,w);
putMacroData(op.dtMacro,w);
putMacroData(op.d2rMacro,w);
putMacroData(op.ssgMacro,w);
putMacroData(op.damMacro,w);
putMacroData(op.dvbMacro,w);
putMacroData(op.egtMacro,w);
putMacroData(op.kslMacro,w);
putMacroData(op.susMacro,w);
putMacroData(op.vibMacro,w);
putMacroData(op.wsMacro,w);
putMacroData(op.ksrMacro,w);
}
// wavesynth macros
putMacroData(std.ws.wave1Macro,w);
putMacroData(std.ws.wave2Macro,w);
putMacroData(std.ws.rateDividerMacro,w);
putMacroData(std.ws.effectMacro,w);
putMacroData(std.ws.oneShotMacro,w);
putMacroData(std.ws.enabledMacro,w);
putMacroData(std.ws.globalMacro,w);
putMacroData(std.ws.speedMacro,w);
putMacroData(std.ws.param1Macro,w);
putMacroData(std.ws.param2Macro,w);
putMacroData(std.ws.param3Macro,w);
putMacroData(std.ws.param4Macro,w);
/*
w->writeI(std.volMacro.len); w->writeI(std.volMacro.len);
w->writeI(std.arpMacro.len); w->writeI(std.arpMacro.len);
w->writeI(std.dutyMacro.len); w->writeI(std.dutyMacro.len);
@ -454,7 +370,7 @@ void DivInstrument::putInsData(SafeWriter* w) {
for (int j=0; j<op.ksrMacro.len; j++) { for (int j=0; j<op.ksrMacro.len; j++) {
w->writeC(op.ksrMacro.val[j]); w->writeC(op.ksrMacro.val[j]);
} }
}*/ }
// OPL drum data // OPL drum data
w->writeC(fm.fixedDrums); w->writeC(fm.fixedDrums);
@ -478,7 +394,6 @@ void DivInstrument::putInsData(SafeWriter* w) {
w->writeC(0); // reserved w->writeC(0); // reserved
// more macros // more macros
/*
w->writeI(std.panLMacro.len); w->writeI(std.panLMacro.len);
w->writeI(std.panRMacro.len); w->writeI(std.panRMacro.len);
w->writeI(std.phaseResetMacro.len); w->writeI(std.phaseResetMacro.len);
@ -538,7 +453,7 @@ void DivInstrument::putInsData(SafeWriter* w) {
} }
for (int j=0; j<std.ex8Macro.len; j++) { for (int j=0; j<std.ex8Macro.len; j++) {
w->writeI(std.ex8Macro.val[j]); w->writeI(std.ex8Macro.val[j]);
}*/ }
// FDS // FDS
w->writeI(fds.modSpeed); w->writeI(fds.modSpeed);
@ -565,43 +480,9 @@ void DivInstrument::putInsData(SafeWriter* w) {
w->writeC(ws.param2); w->writeC(ws.param2);
w->writeC(ws.param3); w->writeC(ws.param3);
w->writeC(ws.param4); w->writeC(ws.param4);
// FM per-operator enable
for (int j=0; j<4; j++) {
DivInstrumentFM::Operator& op=fm.op[j];
w->writeC(op.enable?1:0);
}
}
DivDataErrors DivInstrument::readMacroData(DivInstrumentMacro& m, SafeReader& reader, short version) {
char magic[4];
reader.read(magic,4);
if (memcmp(magic,"MACR",4)!=0) {
logE("invalid macro header!\n");
return DIV_DATA_INVALID_HEADER;
}
reader.readI();
reader.readS(); // format version. ignored.
/*type=(DivInstrumentType)*/reader.readS(); // instrument type
reader.readC();
m.name=reader.readString();
m.len=reader.readI();
m.loop=reader.readI();
m.rel=reader.readI();
m.mode=reader.readI();
m.open=reader.readC();
for (int v=0; v<m.len; v++) {
m.val[v]=reader.readI();
reader.readI(); // reserved
reader.readI(); // reserved
}
return DIV_DATA_SUCCESS;
} }
DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) { DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
bool istest=version&0x80;
char magic[4]; char magic[4];
reader.read(magic,4); reader.read(magic,4);
if (memcmp(magic,"INST",4)!=0) { if (memcmp(magic,"INST",4)!=0) {
@ -611,12 +492,7 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
reader.readI(); reader.readI();
reader.readS(); // format version. ignored. reader.readS(); // format version. ignored.
if (istest) { type=(DivInstrumentType)reader.readC();
type=(DivInstrumentType)reader.readS();
}
if (!istest) {
type=(DivInstrumentType)((unsigned char)reader.readC());
}
mode=(type==DIV_INS_FM); mode=(type==DIV_INS_FM);
reader.readC(); reader.readC();
name=reader.readString(); name=reader.readString();
@ -690,9 +566,7 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
c64.hp=reader.readC(); c64.hp=reader.readC();
c64.ch3off=reader.readC(); c64.ch3off=reader.readC();
c64.cut=reader.readS(); c64.cut=reader.readS();
if (!istest) { c64.dutyIsAbs=reader.readC();
std.dutyMacro.mode=reader.readC();
}
c64.filterIsAbs=reader.readC(); c64.filterIsAbs=reader.readC();
// Amiga // Amiga
@ -700,443 +574,230 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
// reserved // reserved
for (int k=0; k<14; k++) reader.readC(); for (int k=0; k<14; k++) reader.readC();
if (istest) { // standard
if (readMacroData(std.volMacro,reader,version)!=DIV_DATA_SUCCESS) { std.volMacro.len=reader.readI();
return DIV_DATA_INVALID_HEADER; std.arpMacro.len=reader.readI();
} std.dutyMacro.len=reader.readI();
if (readMacroData(std.arpMacro,reader,version)!=DIV_DATA_SUCCESS) { std.waveMacro.len=reader.readI();
return DIV_DATA_INVALID_HEADER; if (version>=17) {
} std.pitchMacro.len=reader.readI();
if (readMacroData(std.dutyMacro,reader,version)!=DIV_DATA_SUCCESS) { std.ex1Macro.len=reader.readI();
return DIV_DATA_INVALID_HEADER; std.ex2Macro.len=reader.readI();
} std.ex3Macro.len=reader.readI();
if (readMacroData(std.waveMacro,reader,version)!=DIV_DATA_SUCCESS) { }
return DIV_DATA_INVALID_HEADER; std.volMacro.loop=reader.readI();
} std.arpMacro.loop=reader.readI();
if (readMacroData(std.pitchMacro,reader,version)!=DIV_DATA_SUCCESS) { std.dutyMacro.loop=reader.readI();
return DIV_DATA_INVALID_HEADER; std.waveMacro.loop=reader.readI();
} if (version>=17) {
if (readMacroData(std.ex1Macro,reader,version)!=DIV_DATA_SUCCESS) { std.pitchMacro.loop=reader.readI();
return DIV_DATA_INVALID_HEADER; std.ex1Macro.loop=reader.readI();
} std.ex2Macro.loop=reader.readI();
if (readMacroData(std.ex2Macro,reader,version)!=DIV_DATA_SUCCESS) { std.ex3Macro.loop=reader.readI();
return DIV_DATA_INVALID_HEADER; }
} std.arpMacro.mode=reader.readC();
if (readMacroData(std.ex3Macro,reader,version)!=DIV_DATA_SUCCESS) { // these 3 were macro heights before but they are not used anymore
return DIV_DATA_INVALID_HEADER; int oldVolHeight=reader.readC();
} int oldDutyHeight=reader.readC();
if (readMacroData(std.algMacro,reader,version)!=DIV_DATA_SUCCESS) { reader.readC(); // oldWaveHeight
return DIV_DATA_INVALID_HEADER; reader.read(std.volMacro.val,4*std.volMacro.len);
} reader.read(std.arpMacro.val,4*std.arpMacro.len);
if (readMacroData(std.fbMacro,reader,version)!=DIV_DATA_SUCCESS) { reader.read(std.dutyMacro.val,4*std.dutyMacro.len);
return DIV_DATA_INVALID_HEADER; reader.read(std.waveMacro.val,4*std.waveMacro.len);
} if (version<31) {
if (readMacroData(std.fmsMacro,reader,version)!=DIV_DATA_SUCCESS) { if (!std.arpMacro.mode) for (int j=0; j<std.arpMacro.len; j++) {
return DIV_DATA_INVALID_HEADER; std.arpMacro.val[j]-=12;
}
if (readMacroData(std.fms2Macro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.amsMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.ams2Macro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.panLMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.panRMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.phaseResetMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.ex4Macro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.ex5Macro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.ex6Macro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.ex7Macro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.ex8Macro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
// FM macros
for (int i=0; i<4; i++) {
DivInstrumentSTD::OpMacro& op=std.opMacros[i];
if (readMacroData(op.amMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(op.arMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(op.drMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(op.multMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(op.rrMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(op.slMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(op.tlMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(op.dt2Macro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(op.rsMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(op.dtMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(op.d2rMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(op.ssgMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(op.damMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(op.dvbMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(op.egtMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(op.kslMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(op.susMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(op.vibMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(op.wsMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(op.ksrMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
}
// wavesynth macros
if (readMacroData(std.ws.wave1Macro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.ws.wave2Macro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.ws.rateDividerMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.ws.effectMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.ws.oneShotMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.ws.enabledMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.ws.globalMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.ws.speedMacro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.ws.param1Macro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.ws.param2Macro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.ws.param3Macro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
}
if (readMacroData(std.ws.param4Macro,reader,version)!=DIV_DATA_SUCCESS) {
return DIV_DATA_INVALID_HEADER;
} }
} }
if (!istest) { if (version>=17) {
// standard reader.read(std.pitchMacro.val,4*std.pitchMacro.len);
std.volMacro.len=reader.readI(); reader.read(std.ex1Macro.val,4*std.ex1Macro.len);
std.arpMacro.len=reader.readI(); reader.read(std.ex2Macro.val,4*std.ex2Macro.len);
std.dutyMacro.len=reader.readI(); reader.read(std.ex3Macro.val,4*std.ex3Macro.len);
std.waveMacro.len=reader.readI(); } else {
if (version>=17) { if (type==DIV_INS_STD) {
std.pitchMacro.len=reader.readI(); if (oldVolHeight==31) {
std.ex1Macro.len=reader.readI(); type=DIV_INS_PCE;
std.ex2Macro.len=reader.readI(); }
std.ex3Macro.len=reader.readI(); if (oldDutyHeight==31) {
} type=DIV_INS_AY;
std.volMacro.loop=reader.readI();
std.arpMacro.loop=reader.readI();
std.dutyMacro.loop=reader.readI();
std.waveMacro.loop=reader.readI();
if (version>=17) {
std.pitchMacro.loop=reader.readI();
std.ex1Macro.loop=reader.readI();
std.ex2Macro.loop=reader.readI();
std.ex3Macro.loop=reader.readI();
}
std.arpMacro.mode=reader.readC();
std.volMacro.height=reader.readC();
std.dutyMacro.height=reader.readC();
std.waveMacro.height=reader.readC();
if (std.volMacro.height==0) std.volMacro.height=15;
if (std.dutyMacro.height==0) std.dutyMacro.height=3;
if (std.waveMacro.height==0) std.waveMacro.height=63;
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);
if (version<31) {
if (!std.arpMacro.mode) for (int j=0; j<std.arpMacro.len; j++) {
std.arpMacro.val[j]-=12;
} }
} }
if (version>=17) { }
reader.read(std.pitchMacro.val,4*std.pitchMacro.len);
reader.read(std.ex1Macro.val,4*std.ex1Macro.len); // FM macros
reader.read(std.ex2Macro.val,4*std.ex2Macro.len); if (version>=29) {
reader.read(std.ex3Macro.val,4*std.ex3Macro.len); std.algMacro.len=reader.readI();
} else { std.fbMacro.len=reader.readI();
if (type==DIV_INS_STD) { std.fmsMacro.len=reader.readI();
if (std.volMacro.height==31) { std.amsMacro.len=reader.readI();
type=DIV_INS_PCE; std.algMacro.loop=reader.readI();
} std.fbMacro.loop=reader.readI();
if (std.dutyMacro.height==31) { std.fmsMacro.loop=reader.readI();
type=DIV_INS_AY; std.amsMacro.loop=reader.readI();
} std.volMacro.open=reader.readC();
} std.arpMacro.open=reader.readC();
std.dutyMacro.open=reader.readC();
std.waveMacro.open=reader.readC();
std.pitchMacro.open=reader.readC();
std.ex1Macro.open=reader.readC();
std.ex2Macro.open=reader.readC();
std.ex3Macro.open=reader.readC();
std.algMacro.open=reader.readC();
std.fbMacro.open=reader.readC();
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);
for (int i=0; i<4; i++) {
DivInstrumentSTD::OpMacro& op=std.opMacros[i];
op.amMacro.len=reader.readI();
op.arMacro.len=reader.readI();
op.drMacro.len=reader.readI();
op.multMacro.len=reader.readI();
op.rrMacro.len=reader.readI();
op.slMacro.len=reader.readI();
op.tlMacro.len=reader.readI();
op.dt2Macro.len=reader.readI();
op.rsMacro.len=reader.readI();
op.dtMacro.len=reader.readI();
op.d2rMacro.len=reader.readI();
op.ssgMacro.len=reader.readI();
op.amMacro.loop=reader.readI();
op.arMacro.loop=reader.readI();
op.drMacro.loop=reader.readI();
op.multMacro.loop=reader.readI();
op.rrMacro.loop=reader.readI();
op.slMacro.loop=reader.readI();
op.tlMacro.loop=reader.readI();
op.dt2Macro.loop=reader.readI();
op.rsMacro.loop=reader.readI();
op.dtMacro.loop=reader.readI();
op.d2rMacro.loop=reader.readI();
op.ssgMacro.loop=reader.readI();
op.amMacro.open=reader.readC();
op.arMacro.open=reader.readC();
op.drMacro.open=reader.readC();
op.multMacro.open=reader.readC();
op.rrMacro.open=reader.readC();
op.slMacro.open=reader.readC();
op.tlMacro.open=reader.readC();
op.dt2Macro.open=reader.readC();
op.rsMacro.open=reader.readC();
op.dtMacro.open=reader.readC();
op.d2rMacro.open=reader.readC();
op.ssgMacro.open=reader.readC();
} }
// FM macros for (int i=0; i<4; i++) {
if (version>=29) { DivInstrumentSTD::OpMacro& op=std.opMacros[i];
std.algMacro.len=reader.readI(); reader.read(op.amMacro.val,op.amMacro.len);
std.fbMacro.len=reader.readI(); reader.read(op.arMacro.val,op.arMacro.len);
std.fmsMacro.len=reader.readI(); reader.read(op.drMacro.val,op.drMacro.len);
std.amsMacro.len=reader.readI(); reader.read(op.multMacro.val,op.multMacro.len);
std.algMacro.loop=reader.readI(); reader.read(op.rrMacro.val,op.rrMacro.len);
std.fbMacro.loop=reader.readI(); reader.read(op.slMacro.val,op.slMacro.len);
std.fmsMacro.loop=reader.readI(); reader.read(op.tlMacro.val,op.tlMacro.len);
std.amsMacro.loop=reader.readI(); reader.read(op.dt2Macro.val,op.dt2Macro.len);
std.volMacro.open=reader.readC(); reader.read(op.rsMacro.val,op.rsMacro.len);
std.arpMacro.open=reader.readC(); reader.read(op.dtMacro.val,op.dtMacro.len);
std.dutyMacro.open=reader.readC(); reader.read(op.d2rMacro.val,op.d2rMacro.len);
std.waveMacro.open=reader.readC(); reader.read(op.ssgMacro.val,op.ssgMacro.len);
std.pitchMacro.open=reader.readC(); }
std.ex1Macro.open=reader.readC(); }
std.ex2Macro.open=reader.readC();
std.ex3Macro.open=reader.readC();
std.algMacro.open=reader.readC();
std.fbMacro.open=reader.readC();
std.fmsMacro.open=reader.readC();
std.amsMacro.open=reader.readC();
reader.read(std.algMacro.val,4*std.algMacro.len); // release points
reader.read(std.fbMacro.val,4*std.fbMacro.len); if (version>=44) {
reader.read(std.fmsMacro.val,4*std.fmsMacro.len); std.volMacro.rel=reader.readI();
reader.read(std.amsMacro.val,4*std.amsMacro.len); std.arpMacro.rel=reader.readI();
std.dutyMacro.rel=reader.readI();
std.waveMacro.rel=reader.readI();
std.pitchMacro.rel=reader.readI();
std.ex1Macro.rel=reader.readI();
std.ex2Macro.rel=reader.readI();
std.ex3Macro.rel=reader.readI();
std.algMacro.rel=reader.readI();
std.fbMacro.rel=reader.readI();
std.fmsMacro.rel=reader.readI();
std.amsMacro.rel=reader.readI();
for (int i=0; i<4; i++) { for (int i=0; i<4; i++) {
DivInstrumentSTD::OpMacro& op=std.opMacros[i]; DivInstrumentSTD::OpMacro& op=std.opMacros[i];
op.amMacro.len=reader.readI(); op.amMacro.rel=reader.readI();
op.arMacro.len=reader.readI(); op.arMacro.rel=reader.readI();
op.drMacro.len=reader.readI(); op.drMacro.rel=reader.readI();
op.multMacro.len=reader.readI(); op.multMacro.rel=reader.readI();
op.rrMacro.len=reader.readI(); op.rrMacro.rel=reader.readI();
op.slMacro.len=reader.readI(); op.slMacro.rel=reader.readI();
op.tlMacro.len=reader.readI(); op.tlMacro.rel=reader.readI();
op.dt2Macro.len=reader.readI(); op.dt2Macro.rel=reader.readI();
op.rsMacro.len=reader.readI(); op.rsMacro.rel=reader.readI();
op.dtMacro.len=reader.readI(); op.dtMacro.rel=reader.readI();
op.d2rMacro.len=reader.readI(); op.d2rMacro.rel=reader.readI();
op.ssgMacro.len=reader.readI(); op.ssgMacro.rel=reader.readI();
}
}
op.amMacro.loop=reader.readI(); // extended op macros
op.arMacro.loop=reader.readI(); if (version>=61) {
op.drMacro.loop=reader.readI(); for (int i=0; i<4; i++) {
op.multMacro.loop=reader.readI(); DivInstrumentSTD::OpMacro& op=std.opMacros[i];
op.rrMacro.loop=reader.readI();
op.slMacro.loop=reader.readI();
op.tlMacro.loop=reader.readI();
op.dt2Macro.loop=reader.readI();
op.rsMacro.loop=reader.readI();
op.dtMacro.loop=reader.readI();
op.d2rMacro.loop=reader.readI();
op.ssgMacro.loop=reader.readI();
op.amMacro.open=reader.readC(); op.damMacro.len=reader.readI();
op.arMacro.open=reader.readC(); op.dvbMacro.len=reader.readI();
op.drMacro.open=reader.readC(); op.egtMacro.len=reader.readI();
op.multMacro.open=reader.readC(); op.kslMacro.len=reader.readI();
op.rrMacro.open=reader.readC(); op.susMacro.len=reader.readI();
op.slMacro.open=reader.readC(); op.vibMacro.len=reader.readI();
op.tlMacro.open=reader.readC(); op.wsMacro.len=reader.readI();
op.dt2Macro.open=reader.readC(); op.ksrMacro.len=reader.readI();
op.rsMacro.open=reader.readC();
op.dtMacro.open=reader.readC();
op.d2rMacro.open=reader.readC();
op.ssgMacro.open=reader.readC();
}
for (int i=0; i<4; i++) { op.damMacro.loop=reader.readI();
DivInstrumentSTD::OpMacro& op=std.opMacros[i]; op.dvbMacro.loop=reader.readI();
for (int l=0; l<op.amMacro.len; l++) { op.egtMacro.loop=reader.readI();
op.amMacro.val[l]=(unsigned char)reader.readC(); op.kslMacro.loop=reader.readI();
} op.susMacro.loop=reader.readI();
for (int l=0; l<op.arMacro.len; l++) { op.vibMacro.loop=reader.readI();
op.arMacro.val[l]=(unsigned char)reader.readC(); op.wsMacro.loop=reader.readI();
} op.ksrMacro.loop=reader.readI();
for (int l=0; l<op.drMacro.len; l++) {
op.drMacro.val[l]=(unsigned char)reader.readC(); op.damMacro.rel=reader.readI();
} op.dvbMacro.rel=reader.readI();
for (int l=0; l<op.multMacro.len; l++) { op.egtMacro.rel=reader.readI();
op.multMacro.val[l]=(unsigned char)reader.readC(); op.kslMacro.rel=reader.readI();
} op.susMacro.rel=reader.readI();
for (int l=0; l<op.rrMacro.len; l++) { op.vibMacro.rel=reader.readI();
op.rrMacro.val[l]=(unsigned char)reader.readC(); op.wsMacro.rel=reader.readI();
} op.ksrMacro.rel=reader.readI();
for (int l=0; l<op.slMacro.len; l++) {
op.slMacro.val[l]=(unsigned char)reader.readC(); op.damMacro.open=reader.readC();
} op.dvbMacro.open=reader.readC();
for (int l=0; l<op.tlMacro.len; l++) { op.egtMacro.open=reader.readC();
op.tlMacro.val[l]=(unsigned char)reader.readC(); op.kslMacro.open=reader.readC();
} op.susMacro.open=reader.readC();
for (int l=0; l<op.dt2Macro.len; l++) { op.vibMacro.open=reader.readC();
op.dt2Macro.val[l]=(unsigned char)reader.readC(); op.wsMacro.open=reader.readC();
} op.ksrMacro.open=reader.readC();
for (int l=0; l<op.rsMacro.len; l++) {
op.rsMacro.val[l]=(unsigned char)reader.readC();
}
for (int l=0; l<op.dtMacro.len; l++) {
op.dtMacro.val[l]=(unsigned char)reader.readC();
}
for (int l=0; l<op.d2rMacro.len; l++) {
op.d2rMacro.val[l]=(unsigned char)reader.readC();
}
for (int l=0; l<op.ssgMacro.len; l++) {
op.ssgMacro.val[l]=(unsigned char)reader.readC();
}
}
} }
// release points for (int i=0; i<4; i++) {
if (version>=44) { DivInstrumentSTD::OpMacro& op=std.opMacros[i];
std.volMacro.rel=reader.readI(); reader.read(op.damMacro.val,op.damMacro.len);
std.arpMacro.rel=reader.readI(); reader.read(op.dvbMacro.val,op.dvbMacro.len);
std.dutyMacro.rel=reader.readI(); reader.read(op.egtMacro.val,op.egtMacro.len);
std.waveMacro.rel=reader.readI(); reader.read(op.kslMacro.val,op.kslMacro.len);
std.pitchMacro.rel=reader.readI(); reader.read(op.susMacro.val,op.susMacro.len);
std.ex1Macro.rel=reader.readI(); reader.read(op.vibMacro.val,op.vibMacro.len);
std.ex2Macro.rel=reader.readI(); reader.read(op.wsMacro.val,op.wsMacro.len);
std.ex3Macro.rel=reader.readI(); reader.read(op.ksrMacro.val,op.ksrMacro.len);
std.algMacro.rel=reader.readI();
std.fbMacro.rel=reader.readI();
std.fmsMacro.rel=reader.readI();
std.amsMacro.rel=reader.readI();
for (int i=0; i<4; i++) {
DivInstrumentSTD::OpMacro& op=std.opMacros[i];
op.amMacro.rel=reader.readI();
op.arMacro.rel=reader.readI();
op.drMacro.rel=reader.readI();
op.multMacro.rel=reader.readI();
op.rrMacro.rel=reader.readI();
op.slMacro.rel=reader.readI();
op.tlMacro.rel=reader.readI();
op.dt2Macro.rel=reader.readI();
op.rsMacro.rel=reader.readI();
op.dtMacro.rel=reader.readI();
op.d2rMacro.rel=reader.readI();
op.ssgMacro.rel=reader.readI();
}
}
// extended op macros
if (version>=61) {
for (int i=0; i<4; i++) {
DivInstrumentSTD::OpMacro& op=std.opMacros[i];
op.damMacro.len=reader.readI();
op.dvbMacro.len=reader.readI();
op.egtMacro.len=reader.readI();
op.kslMacro.len=reader.readI();
op.susMacro.len=reader.readI();
op.vibMacro.len=reader.readI();
op.wsMacro.len=reader.readI();
op.ksrMacro.len=reader.readI();
op.damMacro.loop=reader.readI();
op.dvbMacro.loop=reader.readI();
op.egtMacro.loop=reader.readI();
op.kslMacro.loop=reader.readI();
op.susMacro.loop=reader.readI();
op.vibMacro.loop=reader.readI();
op.wsMacro.loop=reader.readI();
op.ksrMacro.loop=reader.readI();
op.damMacro.rel=reader.readI();
op.dvbMacro.rel=reader.readI();
op.egtMacro.rel=reader.readI();
op.kslMacro.rel=reader.readI();
op.susMacro.rel=reader.readI();
op.vibMacro.rel=reader.readI();
op.wsMacro.rel=reader.readI();
op.ksrMacro.rel=reader.readI();
op.damMacro.open=reader.readC();
op.dvbMacro.open=reader.readC();
op.egtMacro.open=reader.readC();
op.kslMacro.open=reader.readC();
op.susMacro.open=reader.readC();
op.vibMacro.open=reader.readC();
op.wsMacro.open=reader.readC();
op.ksrMacro.open=reader.readC();
}
for (int i=0; i<4; i++) {
DivInstrumentSTD::OpMacro& op=std.opMacros[i];
for (int l=0; l<op.damMacro.len; l++) {
op.damMacro.val[l]=(unsigned char)reader.readC();
}
for (int l=0; l<op.dvbMacro.len; l++) {
op.dvbMacro.val[l]=(unsigned char)reader.readC();
}
for (int l=0; l<op.egtMacro.len; l++) {
op.egtMacro.val[l]=(unsigned char)reader.readC();
}
for (int l=0; l<op.kslMacro.len; l++) {
op.kslMacro.val[l]=(unsigned char)reader.readC();
}
for (int l=0; l<op.susMacro.len; l++) {
op.susMacro.val[l]=(unsigned char)reader.readC();
}
for (int l=0; l<op.vibMacro.len; l++) {
op.vibMacro.val[l]=(unsigned char)reader.readC();
}
for (int l=0; l<op.wsMacro.len; l++) {
op.wsMacro.val[l]=(unsigned char)reader.readC();
}
for (int l=0; l<op.ksrMacro.len; l++) {
op.ksrMacro.val[l]=(unsigned char)reader.readC();
}
}
} }
} }
@ -1182,53 +843,51 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
} }
// more macros // more macros
if (!istest) { if (version>=76) {
if (version>=76) { std.panLMacro.len=reader.readI();
std.panLMacro.len=reader.readI(); std.panRMacro.len=reader.readI();
std.panRMacro.len=reader.readI(); std.phaseResetMacro.len=reader.readI();
std.phaseResetMacro.len=reader.readI(); std.ex4Macro.len=reader.readI();
std.ex4Macro.len=reader.readI(); std.ex5Macro.len=reader.readI();
std.ex5Macro.len=reader.readI(); std.ex6Macro.len=reader.readI();
std.ex6Macro.len=reader.readI(); std.ex7Macro.len=reader.readI();
std.ex7Macro.len=reader.readI(); std.ex8Macro.len=reader.readI();
std.ex8Macro.len=reader.readI();
std.panLMacro.loop=reader.readI(); std.panLMacro.loop=reader.readI();
std.panRMacro.loop=reader.readI(); std.panRMacro.loop=reader.readI();
std.phaseResetMacro.loop=reader.readI(); std.phaseResetMacro.loop=reader.readI();
std.ex4Macro.loop=reader.readI(); std.ex4Macro.loop=reader.readI();
std.ex5Macro.loop=reader.readI(); std.ex5Macro.loop=reader.readI();
std.ex6Macro.loop=reader.readI(); std.ex6Macro.loop=reader.readI();
std.ex7Macro.loop=reader.readI(); std.ex7Macro.loop=reader.readI();
std.ex8Macro.loop=reader.readI(); std.ex8Macro.loop=reader.readI();
std.panLMacro.rel=reader.readI(); std.panLMacro.rel=reader.readI();
std.panRMacro.rel=reader.readI(); std.panRMacro.rel=reader.readI();
std.phaseResetMacro.rel=reader.readI(); std.phaseResetMacro.rel=reader.readI();
std.ex4Macro.rel=reader.readI(); std.ex4Macro.rel=reader.readI();
std.ex5Macro.rel=reader.readI(); std.ex5Macro.rel=reader.readI();
std.ex6Macro.rel=reader.readI(); std.ex6Macro.rel=reader.readI();
std.ex7Macro.rel=reader.readI(); std.ex7Macro.rel=reader.readI();
std.ex8Macro.rel=reader.readI(); std.ex8Macro.rel=reader.readI();
std.panLMacro.open=reader.readC(); std.panLMacro.open=reader.readC();
std.panRMacro.open=reader.readC(); std.panRMacro.open=reader.readC();
std.phaseResetMacro.open=reader.readC(); std.phaseResetMacro.open=reader.readC();
std.ex4Macro.open=reader.readC(); std.ex4Macro.open=reader.readC();
std.ex5Macro.open=reader.readC(); std.ex5Macro.open=reader.readC();
std.ex6Macro.open=reader.readC(); std.ex6Macro.open=reader.readC();
std.ex7Macro.open=reader.readC(); std.ex7Macro.open=reader.readC();
std.ex8Macro.open=reader.readC(); std.ex8Macro.open=reader.readC();
reader.read(std.panLMacro.val,4*std.panLMacro.len); reader.read(std.panLMacro.val,4*std.panLMacro.len);
reader.read(std.panRMacro.val,4*std.panRMacro.len); reader.read(std.panRMacro.val,4*std.panRMacro.len);
reader.read(std.phaseResetMacro.val,4*std.phaseResetMacro.len); reader.read(std.phaseResetMacro.val,4*std.phaseResetMacro.len);
reader.read(std.ex4Macro.val,4*std.ex4Macro.len); reader.read(std.ex4Macro.val,4*std.ex4Macro.len);
reader.read(std.ex5Macro.val,4*std.ex5Macro.len); reader.read(std.ex5Macro.val,4*std.ex5Macro.len);
reader.read(std.ex6Macro.val,4*std.ex6Macro.len); reader.read(std.ex6Macro.val,4*std.ex6Macro.len);
reader.read(std.ex7Macro.val,4*std.ex7Macro.len); reader.read(std.ex7Macro.val,4*std.ex7Macro.len);
reader.read(std.ex8Macro.val,4*std.ex8Macro.len); reader.read(std.ex8Macro.val,4*std.ex8Macro.len);
}
} }
// FDS // FDS
@ -1262,14 +921,6 @@ DivDataErrors DivInstrument::readInsData(SafeReader& reader, short version) {
ws.param3=reader.readC(); ws.param3=reader.readC();
ws.param4=reader.readC(); ws.param4=reader.readC();
} }
// FM per-operator enable
if (istest) {
for (int j=0; j<4; j++) {
DivInstrumentFM::Operator& op=fm.op[j];
op.enable=reader.readC();
}
}
return DIV_DATA_SUCCESS; return DIV_DATA_SUCCESS;
} }

51
src/engine/instrument.h
View file

@ -26,7 +26,7 @@
// NOTICE! // NOTICE!
// before adding new instrument types to this struct, please ask me first. // before adding new instrument types to this struct, please ask me first.
// absolutely zero support granted to conflicting formats. // absolutely zero support granted to conflicting formats.
enum DivInstrumentType : unsigned short { enum DivInstrumentType: unsigned short {
DIV_INS_STD=0, DIV_INS_STD=0,
DIV_INS_FM=1, DIV_INS_FM=1,
DIV_INS_GB=2, DIV_INS_GB=2,
@ -81,7 +81,7 @@ struct DivInstrumentFM {
unsigned char am, ar, dr, mult, rr, sl, tl, dt2, rs, dt, d2r, ssgEnv; unsigned char am, ar, dr, mult, rr, sl, tl, dt2, rs, dt, d2r, ssgEnv;
unsigned char dam, dvb, egt, ksl, sus, vib, ws, ksr; // YMU759/OPL/OPZ unsigned char dam, dvb, egt, ksl, sus, vib, ws, ksr; // YMU759/OPL/OPZ
Operator(): Operator():
enable(false), enable(true),
am(0), am(0),
ar(0), ar(0),
dr(0), dr(0),
@ -156,22 +156,20 @@ struct DivInstrumentFM {
struct DivInstrumentMacro { struct DivInstrumentMacro {
String name; String name;
int val[256]; int val[256];
int height;
unsigned int mode; unsigned int mode;
bool open; bool open;
unsigned char len; unsigned char len;
signed char loop; signed char loop;
signed char rel; signed char rel;
DivInstrumentMacro(String n, int h=~0, bool initOpen=false): DivInstrumentMacro(String n, bool initOpen=false):
name(n), name(n),
height(h),
mode(0), mode(0),
open(initOpen), open(initOpen),
len(0), len(0),
loop(-1), loop(-1),
rel(-1) { rel(-1) {
memset(val,0,256*sizeof(int)); memset(val,0,256*sizeof(int));
} }
}; };
struct DivInstrumentSTD { struct DivInstrumentSTD {
@ -186,9 +184,7 @@ struct DivInstrumentSTD {
DivInstrumentMacro algMacro; DivInstrumentMacro algMacro;
DivInstrumentMacro fbMacro; DivInstrumentMacro fbMacro;
DivInstrumentMacro fmsMacro; DivInstrumentMacro fmsMacro;
DivInstrumentMacro fms2Macro;
DivInstrumentMacro amsMacro; DivInstrumentMacro amsMacro;
DivInstrumentMacro ams2Macro;
DivInstrumentMacro panLMacro; DivInstrumentMacro panLMacro;
DivInstrumentMacro panRMacro; DivInstrumentMacro panRMacro;
DivInstrumentMacro phaseResetMacro; DivInstrumentMacro phaseResetMacro;
@ -222,36 +218,16 @@ struct DivInstrumentSTD {
DivInstrumentMacro ksrMacro; DivInstrumentMacro ksrMacro;
OpMacro(): OpMacro():
amMacro("am"), arMacro("ar"), drMacro("dr"), multMacro("mult"), amMacro("am"), arMacro("ar"), drMacro("dr"), multMacro("mult"),
rrMacro("rr"), slMacro("sl"), tlMacro("tl",~0,true), dt2Macro("dt2"), rrMacro("rr"), slMacro("sl"), tlMacro("tl",true), dt2Macro("dt2"),
rsMacro("rs"), dtMacro("dt"), d2rMacro("d2r"), ssgMacro("ssg"), rsMacro("rs"), dtMacro("dt"), d2rMacro("d2r"), ssgMacro("ssg"),
damMacro("dam"), dvbMacro("dvb"), egtMacro("egt"), kslMacro("ksl"), damMacro("dam"), dvbMacro("dvb"), egtMacro("egt"), kslMacro("ksl"),
susMacro("sus"), vibMacro("vib"), wsMacro("ws"), ksrMacro("ksr") {} susMacro("sus"), vibMacro("vib"), wsMacro("ws"), ksrMacro("ksr") {}
} opMacros[4]; } opMacros[4];
struct WaveSynthMacro {
DivInstrumentMacro wave1Macro, wave2Macro;
DivInstrumentMacro rateDividerMacro;
DivInstrumentMacro effectMacro;
DivInstrumentMacro oneShotMacro, enabledMacro, globalMacro;
DivInstrumentMacro speedMacro, param1Macro, param2Macro, param3Macro, param4Macro;
WaveSynthMacro():
wave1Macro("wave1"),
wave2Macro("wave2"),
rateDividerMacro("rateDivider"),
effectMacro("effect"),
oneShotMacro("oneShot"),
enabledMacro("enabled"),
globalMacro("global"),
speedMacro("speed"),
param1Macro("param1"),
param2Macro("param2"),
param3Macro("param3"),
param4Macro("param4") {}
} ws;
DivInstrumentSTD(): DivInstrumentSTD():
volMacro("vol",15,true), volMacro("vol",true),
arpMacro("arp"), arpMacro("arp"),
dutyMacro("duty",3), dutyMacro("duty"),
waveMacro("wave",63), waveMacro("wave"),
pitchMacro("pitch"), pitchMacro("pitch"),
ex1Macro("ex1"), ex1Macro("ex1"),
ex2Macro("ex2"), ex2Macro("ex2"),
@ -259,9 +235,7 @@ struct DivInstrumentSTD {
algMacro("alg"), algMacro("alg"),
fbMacro("fb"), fbMacro("fb"),
fmsMacro("fms"), fmsMacro("fms"),
fms2Macro("fms2"),
amsMacro("ams"), amsMacro("ams"),
ams2Macro("ams2"),
panLMacro("panL"), panLMacro("panL"),
panRMacro("panR"), panRMacro("panR"),
phaseResetMacro("phaseReset"), phaseResetMacro("phaseReset"),
@ -425,15 +399,6 @@ struct DivInstrument {
*/ */
DivDataErrors readInsData(SafeReader& reader, short version); DivDataErrors readInsData(SafeReader& reader, short version);
/**
* read macro data in .fui format.
* @param m the macro.
* @param reader the reader.
* @param version the format version.
* @return a DivDataErrors.
*/
DivDataErrors readMacroData(DivInstrumentMacro& m, SafeReader& reader, short version);
/** /**
* save this instrument to a file. * save this instrument to a file.
* @param path file path. * @param path file path.

53
src/engine/macroInt.cpp
View file

@ -45,10 +45,10 @@ void DivMacroStruct::doMacro(DivInstrumentMacro& source, bool released) {
} }
} }
// CPU hell
void DivMacroInt::next() { void DivMacroInt::next() {
if (ins==NULL) return; if (ins==NULL) return;
// Run macros // run macros
// TODO: potentially get rid of list to avoid allocations
if (!macroList.empty()) { if (!macroList.empty()) {
for (std::list<DivMacroExecList>::iterator iter = macroList.begin(); iter!= macroList.end(); iter++) { for (std::list<DivMacroExecList>::iterator iter = macroList.begin(); iter!= macroList.end(); iter++) {
iter->doMacro(released); iter->doMacro(released);
@ -63,6 +63,7 @@ void DivMacroInt::release() {
void DivMacroInt::init(DivInstrument* which) { void DivMacroInt::init(DivInstrument* which) {
ins=which; ins=which;
// initialize // initialize
// TODO: potentially get rid of list to avoid allocations
while (!macroList.empty()) { while (!macroList.empty()) {
macroList.front().init(); macroList.front().init();
macroList.pop_front(); macroList.pop_front();
@ -106,17 +107,10 @@ void DivMacroInt::init(DivInstrument* which) {
if (ins->std.fmsMacro.len>0) { if (ins->std.fmsMacro.len>0) {
macroList.push_back(DivMacroExecList(fms,ins->std.fmsMacro)); macroList.push_back(DivMacroExecList(fms,ins->std.fmsMacro));
} }
if (ins->std.fms2Macro.len>0) {
macroList.push_back(DivMacroExecList(fms2,ins->std.fms2Macro));
}
if (ins->std.amsMacro.len>0) { if (ins->std.amsMacro.len>0) {
macroList.push_back(DivMacroExecList(ams,ins->std.amsMacro)); macroList.push_back(DivMacroExecList(ams,ins->std.amsMacro));
} }
if (ins->std.ams2Macro.len>0) {
macroList.push_back(DivMacroExecList(ams2,ins->std.ams2Macro));
}
// TODO: other macros
if (ins->std.panLMacro.len>0) { if (ins->std.panLMacro.len>0) {
macroList.push_back(DivMacroExecList(panL,ins->std.panLMacro)); macroList.push_back(DivMacroExecList(panL,ins->std.panLMacro));
} }
@ -209,46 +203,9 @@ void DivMacroInt::init(DivInstrument* which) {
} }
} }
// prepare wavesynth macros
if (ins->std.ws.wave1Macro.len>0) {
macroList.push_back(DivMacroExecList(ws.wave1,ins->std.ws.wave1Macro));
}
if (ins->std.ws.wave2Macro.len>0) {
macroList.push_back(DivMacroExecList(ws.wave2,ins->std.ws.wave2Macro));
}
if (ins->std.ws.rateDividerMacro.len>0) {
macroList.push_back(DivMacroExecList(ws.rateDivider,ins->std.ws.rateDividerMacro));
}
if (ins->std.ws.effectMacro.len>0) {
macroList.push_back(DivMacroExecList(ws.effect,ins->std.ws.effectMacro));
}
if (ins->std.ws.oneShotMacro.len>0) {
macroList.push_back(DivMacroExecList(ws.oneShot,ins->std.ws.oneShotMacro));
}
if (ins->std.ws.enabledMacro.len>0) {
macroList.push_back(DivMacroExecList(ws.enabled,ins->std.ws.enabledMacro));
}
if (ins->std.ws.globalMacro.len>0) {
macroList.push_back(DivMacroExecList(ws.global,ins->std.ws.globalMacro));
}
if (ins->std.ws.speedMacro.len>0) {
macroList.push_back(DivMacroExecList(ws.speed,ins->std.ws.speedMacro));
}
if (ins->std.ws.param1Macro.len>0) {
macroList.push_back(DivMacroExecList(ws.param1,ins->std.ws.param1Macro));
}
if (ins->std.ws.param2Macro.len>0) {
macroList.push_back(DivMacroExecList(ws.param2,ins->std.ws.param2Macro));
}
if (ins->std.ws.param3Macro.len>0) {
macroList.push_back(DivMacroExecList(ws.param3,ins->std.ws.param3Macro));
}
if (ins->std.ws.param4Macro.len>0) {
macroList.push_back(DivMacroExecList(ws.param4,ins->std.ws.param4Macro));
}
if (!macroList.empty()) { if (!macroList.empty()) {
for (std::list<DivMacroExecList>::iterator iter = macroList.begin(); iter!= macroList.end(); iter++) { for (std::list<DivMacroExecList>::iterator iter = macroList.begin(); iter!= macroList.end(); iter++) {
iter->prepare(); iter->prepare();
} }
} }
} }

26
src/engine/macroInt.h
View file

@ -73,7 +73,7 @@ class DivMacroInt {
DivMacroStruct vol; DivMacroStruct vol;
DivMacroStruct arp; DivMacroStruct arp;
DivMacroStruct duty, wave, pitch, ex1, ex2, ex3; DivMacroStruct duty, wave, pitch, ex1, ex2, ex3;
DivMacroStruct alg, fb, fms, fms2, ams, ams2; DivMacroStruct alg, fb, fms, ams;
DivMacroStruct panL, panR, phaseReset, ex4, ex5, ex6, ex7, ex8; DivMacroStruct panL, panR, phaseReset, ex4, ex5, ex6, ex7, ex8;
// FM operator macro // FM operator macro
@ -105,28 +105,6 @@ class DivMacroInt {
ws(), ws(),
ksr() {} ksr() {}
} op[4]; } op[4];
// wavesynth macro
struct IntWS {
DivMacroStruct wave1, wave2;
DivMacroStruct rateDivider;
DivMacroStruct effect;
DivMacroStruct oneShot, enabled, global;
DivMacroStruct speed, param1, param2, param3, param4;
IntWS():
wave1(),
wave2(),
rateDivider(),
effect(),
oneShot(),
enabled(),
global(),
speed(),
param1(),
param2(),
param3(),
param4() {}
} ws;
/** /**
* trigger macro release. * trigger macro release.
@ -165,9 +143,7 @@ class DivMacroInt {
alg(), alg(),
fb(), fb(),
fms(), fms(),
fms2(),
ams(), ams(),
ams2(),
panL(), panL(),
panR(), panR(),
phaseReset(), phaseReset(),

8
src/engine/platform/tx81z.cpp
View file

@ -275,18 +275,10 @@ void DivPlatformTX81Z::tick() {
chan[i].state.fms=chan[i].std.fms.val; chan[i].state.fms=chan[i].std.fms.val;
rWrite(chanOffs[i]+ADDR_FMS_AMS,((chan[i].state.fms&7)<<4)|(chan[i].state.ams&3)); rWrite(chanOffs[i]+ADDR_FMS_AMS,((chan[i].state.fms&7)<<4)|(chan[i].state.ams&3));
} }
if (chan[i].std.fms2.had) {
chan[i].state.fms2=chan[i].std.fms2.val;
//rWrite(chanOffs[i]+ADDR_FMS_AMS,0x84|((chan[i].state.fms2&7)<<4)|(chan[i].state.ams2&3));
}
if (chan[i].std.ams.had) { if (chan[i].std.ams.had) {
chan[i].state.ams=chan[i].std.ams.val; chan[i].state.ams=chan[i].std.ams.val;
rWrite(chanOffs[i]+ADDR_FMS_AMS,((chan[i].state.fms&7)<<4)|(chan[i].state.ams&3)); rWrite(chanOffs[i]+ADDR_FMS_AMS,((chan[i].state.fms&7)<<4)|(chan[i].state.ams&3));
} }
if (chan[i].std.ams2.had) {
chan[i].state.ams2=chan[i].std.ams2.val;
//rWrite(chanOffs[i]+ADDR_FMS_AMS,0x84|((chan[i].state.fms2&7)<<4)|(chan[i].state.ams2&3));
}
for (int j=0; j<4; j++) { for (int j=0; j<4; j++) {
unsigned short baseAddr=chanOffs[i]|opOffs[j]; unsigned short baseAddr=chanOffs[i]|opOffs[j];
DivInstrumentFM::Operator& op=chan[i].state.op[j]; DivInstrumentFM::Operator& op=chan[i].state.op[j];

44
src/gui/insEdit.cpp
View file

@ -110,7 +110,7 @@ enum FMParams {
#define FM_SHORT_NAME(x) fmParamShortNames[settings.fmNames][x] #define FM_SHORT_NAME(x) fmParamShortNames[settings.fmNames][x]
const char* fmOperatorBits[5]={ const char* fmOperatorBits[5]={
"op1", "op3", "op2", "op4", NULL "op1", "op2", "op3", "op4", NULL
}; };
const char* c64ShapeBits[5]={ const char* c64ShapeBits[5]={
@ -182,11 +182,12 @@ const char* dualWSEffects[7]={
const char* macroAbsoluteMode[2]={ const char* macroAbsoluteMode[2]={
"Relative", "Relative",
"Absolute", "Absolute"
}; };
const char* macroDummyMode[2]={ const char* macroDummyMode[2]={
"empty", "Bug",
"Bug"
}; };
String macroHoverNote(int id, float val) { String macroHoverNote(int id, float val) {
@ -996,7 +997,7 @@ void FurnaceGUI::drawFMEnv(unsigned char tl, unsigned char ar, unsigned char dr,
} else { \ } else { \
modeName=displayModeName[macro.mode]; \ modeName=displayModeName[macro.mode]; \
} \ } \
if (ImGui::BeginCombo("Macro Mode##IMacroMode_" macroName,modeName.c_str())) { \ if (ImGui::BeginCombo("TODO: Improve##IMacroMode_" macroName,modeName.c_str())) { \
String id; \ String id; \
for (unsigned int i=0; i<=macroModeMax; i++) { \ for (unsigned int i=0; i<=macroModeMax; i++) { \
id=fmt::sprintf("%d: %s",i,displayModeName[i]); \ id=fmt::sprintf("%d: %s",i,displayModeName[i]); \
@ -1100,7 +1101,7 @@ void FurnaceGUI::drawFMEnv(unsigned char tl, unsigned char ar, unsigned char dr,
} else { \ } else { \
modeName=displayModeName[macro.mode]; \ modeName=displayModeName[macro.mode]; \
} \ } \
if (ImGui::BeginCombo("Macro Mode##IOPMacroMode_" macroName,modeName.c_str())) { \ if (ImGui::BeginCombo("TODO: Improve##IOPMacroMode_" macroName,modeName.c_str())) { \
String id; \ String id; \
for (unsigned int i=0; i<=macroModeMax; i++) { \ for (unsigned int i=0; i<=macroModeMax; i++) { \
id=fmt::sprintf("%d: %s",i,displayModeName[i]); \ id=fmt::sprintf("%d: %s",i,displayModeName[i]); \
@ -2056,10 +2057,9 @@ void FurnaceGUI::drawInsEdit() {
NORMAL_MACRO(ins->std.fbMacro,0,7,"fb",FM_NAME(FM_FB),96,ins->std.fbMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[1],0,7,NULL,false); NORMAL_MACRO(ins->std.fbMacro,0,7,"fb",FM_NAME(FM_FB),96,ins->std.fbMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[1],0,7,NULL,false);
if (ins->type!=DIV_INS_OPL) { if (ins->type!=DIV_INS_OPL) {
if (ins->type==DIV_INS_OPZ) { if (ins->type==DIV_INS_OPZ) {
// TODO: FMS2/AMS2 macros
NORMAL_MACRO(ins->std.fmsMacro,0,7,"fms",FM_NAME(FM_FMS),96,ins->std.fmsMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[2],0,7,NULL,false); NORMAL_MACRO(ins->std.fmsMacro,0,7,"fms",FM_NAME(FM_FMS),96,ins->std.fmsMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[2],0,7,NULL,false);
NORMAL_MACRO(ins->std.fms2Macro,0,7,"fms2",FM_NAME(FM_FMS2),96,ins->std.fms2Macro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[3],0,7,NULL,false);
NORMAL_MACRO(ins->std.amsMacro,0,3,"ams",FM_NAME(FM_AMS),48,ins->std.amsMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[4],0,3,NULL,false); NORMAL_MACRO(ins->std.amsMacro,0,3,"ams",FM_NAME(FM_AMS),48,ins->std.amsMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[4],0,3,NULL,false);
NORMAL_MACRO(ins->std.ams2Macro,0,3,"ams2",FM_NAME(FM_AMS2),48,ins->std.ams2Macro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[5],0,3,NULL,false);
} else { } else {
NORMAL_MACRO(ins->std.fmsMacro,0,7,"fms",FM_NAME(FM_FMS),96,ins->std.fmsMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[2],0,7,NULL,false); NORMAL_MACRO(ins->std.fmsMacro,0,7,"fms",FM_NAME(FM_FMS),96,ins->std.fmsMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[2],0,7,NULL,false);
NORMAL_MACRO(ins->std.amsMacro,0,3,"ams",FM_NAME(FM_AMS),48,ins->std.amsMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[3],0,3,NULL,false); NORMAL_MACRO(ins->std.amsMacro,0,3,"ams",FM_NAME(FM_AMS),48,ins->std.amsMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[3],0,3,NULL,false);
@ -2072,7 +2072,7 @@ void FurnaceGUI::drawInsEdit() {
NORMAL_MACRO(ins->std.ex2Macro,0,127,"ex2","PM Depth",128,ins->std.ex2Macro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[7],0,127,NULL,false); NORMAL_MACRO(ins->std.ex2Macro,0,127,"ex2","PM Depth",128,ins->std.ex2Macro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[7],0,127,NULL,false);
NORMAL_MACRO(ins->std.ex3Macro,0,255,"ex3","LFO Speed",128,ins->std.ex3Macro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[8],0,255,NULL,false); NORMAL_MACRO(ins->std.ex3Macro,0,255,"ex3","LFO Speed",128,ins->std.ex3Macro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[8],0,255,NULL,false);
NORMAL_MACRO(ins->std.waveMacro,0,3,"wave","LFO Shape",48,ins->std.waveMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_WAVE],mmlString[9],0,3,&macroLFOWaves,false); NORMAL_MACRO(ins->std.waveMacro,0,3,"wave","LFO Shape",48,ins->std.waveMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_WAVE],mmlString[9],0,3,&macroLFOWaves,false);
NORMAL_MACRO(ins->std.ex4Macro,0,4,"ex4","Operator On/Off",128,ins->std.ex4Macro.open,true,fmOperatorBits,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[10],0,4,NULL,false); NORMAL_MACRO(ins->std.ex4Macro,0,4,"ex4","OpMask",128,ins->std.ex4Macro.open,true,fmOperatorBits,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[10],0,4,NULL,false);
} }
MACRO_END; MACRO_END;
ImGui::EndTabItem(); ImGui::EndTabItem();
@ -2238,10 +2238,7 @@ void FurnaceGUI::drawInsEdit() {
P(ImGui::Checkbox("Volume Macro is Cutoff Macro",&ins->c64.volIsCutoff)); P(ImGui::Checkbox("Volume Macro is Cutoff Macro",&ins->c64.volIsCutoff));
P(ImGui::Checkbox("Absolute Cutoff Macro",&ins->c64.filterIsAbs)); P(ImGui::Checkbox("Absolute Cutoff Macro",&ins->c64.filterIsAbs));
bool dutyAbs=ins->std.dutyMacro.mode&1; P(ImGui::Checkbox("Absolute Duty Macro",&ins->c64.dutyIsAbs));
if (ImGui::Checkbox("Absolute Duty Macro",&dutyAbs)) { PARAMETER
ins->std.dutyMacro.mode^=1;
}
ImGui::EndTabItem(); ImGui::EndTabItem();
} }
if (ins->type==DIV_INS_AMIGA) if (ImGui::BeginTabItem("Amiga/Sample")) { if (ins->type==DIV_INS_AMIGA) if (ImGui::BeginTabItem("Amiga/Sample")) {
@ -2387,9 +2384,6 @@ void FurnaceGUI::drawInsEdit() {
ins->type==DIV_INS_SWAN || ins->type==DIV_INS_SWAN ||
ins->type==DIV_INS_PCE || ins->type==DIV_INS_PCE ||
ins->type==DIV_INS_SCC) { ins->type==DIV_INS_SCC) {
float asFloat[256];
int asInt[256];
float loopIndicator[256];
if (ImGui::BeginTabItem("Wavetable")) { if (ImGui::BeginTabItem("Wavetable")) {
ImGui::Checkbox("Enable synthesizer",&ins->ws.enabled); ImGui::Checkbox("Enable synthesizer",&ins->ws.enabled);
ImGui::SameLine(); ImGui::SameLine();
@ -2484,20 +2478,6 @@ void FurnaceGUI::drawInsEdit() {
ImGui::EndTabItem(); ImGui::EndTabItem();
} }
if (ImGui::BeginTabItem("Wavetable Macros")) {
MACRO_BEGIN(0);
NORMAL_MACRO(ins->std.ws.enabledMacro,0,1,"enabled","Enable",160,ins->std.ws.enabledMacro.open,true,oneBit,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[5],0,1,NULL,false);
NORMAL_MACRO(ins->std.ws.oneShotMacro,0,1,"oneShot","One Shot",160,ins->std.ws.oneShotMacro.open,true,oneBit,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[4],0,1,NULL,false);
NORMAL_MACRO(ins->std.ws.globalMacro,0,1,"global","Global",160,ins->std.ws.globalMacro.open,true,oneBit,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[6],0,1,NULL,false);
NORMAL_MACRO(ins->std.ws.effectMacro,0,255,"effect","Effect",160,ins->std.ws.effectMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[3],0,255,NULL,false);
NORMAL_MACRO(ins->std.ws.wave1Macro,0,255,"wave1","Wave 1",160,ins->std.ws.wave1Macro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[0],0,255,NULL,false);
NORMAL_MACRO(ins->std.ws.wave2Macro,0,255,"wave2","Wave 2",160,ins->std.ws.wave2Macro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[1],0,255,NULL,false);
NORMAL_MACRO(ins->std.ws.rateDividerMacro,1,7,"rateDivider","Rate",160,ins->std.ws.rateDividerMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[2],1,7,NULL,false);
NORMAL_MACRO(ins->std.ws.speedMacro,0,255,"speed","Speed",160,ins->std.ws.speedMacro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[6],0,255,NULL,false);
NORMAL_MACRO(ins->std.ws.param1Macro,1,7,"amount","Amount",160,ins->std.ws.param1Macro.open,false,NULL,false,NULL,0,0,0,false,0,macroDummyMode,uiColors[GUI_COLOR_MACRO_OTHER],mmlString[6],1,7,NULL,false);
MACRO_END;
ImGui::EndTabItem();
}
} }
if (ImGui::BeginTabItem("Macros")) { if (ImGui::BeginTabItem("Macros")) {
float asFloat[256]; float asFloat[256];
@ -2546,7 +2526,7 @@ void FurnaceGUI::drawInsEdit() {
int dutyMax=3; int dutyMax=3;
if (ins->type==DIV_INS_C64) { if (ins->type==DIV_INS_C64) {
dutyLabel="Duty"; dutyLabel="Duty";
if (ins->std.dutyMacro.mode) { if (ins->c64.dutyIsAbs) {
dutyMax=4095; dutyMax=4095;
} else { } else {
dutyMax=24; dutyMax=24;
@ -2593,7 +2573,7 @@ void FurnaceGUI::drawInsEdit() {
dutyLabel="Duty"; dutyLabel="Duty";
dutyMax=7; dutyMax=7;
} }
bool dutyIsRel=(ins->type==DIV_INS_C64 && !ins->std.dutyMacro.mode); bool dutyIsRel=(ins->type==DIV_INS_C64 && !ins->c64.dutyIsAbs);
const char* waveLabel="Waveform"; const char* waveLabel="Waveform";
int waveMax=(ins->type==DIV_INS_AY || ins->type==DIV_INS_AY8930 || ins->type==DIV_INS_VERA)?3:63; int waveMax=(ins->type==DIV_INS_AY || ins->type==DIV_INS_AY8930 || ins->type==DIV_INS_VERA)?3:63;
@ -2813,7 +2793,7 @@ void FurnaceGUI::drawInsEdit() {
if (dutyMax>0) { if (dutyMax>0) {
ImGui::Separator(); ImGui::Separator();
if (ins->type==DIV_INS_C64) { if (ins->type==DIV_INS_C64) {
if (ins->std.dutyMacro.mode) { if (ins->c64.dutyIsAbs) {
ImGui::Text("Duty Macro"); ImGui::Text("Duty Macro");
} else { } else {
ImGui::Text("Relative Duty Macro"); ImGui::Text("Relative Duty Macro");