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

implement macro masking

Browse source
This commit is contained in:
tildearrow 2022-12-17 00:09:56 -05:00
parent f5667fac1f
commit 9da46ee8ba
64 changed files with 760 additions and 268 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/engine/platform/amiga.cpp
View file

@ -349,6 +349,12 @@ int DivPlatformAmiga::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 64;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/arcade.cpp
View file

@ -726,6 +726,12 @@ int DivPlatformArcade::dispatch(DivCommand c) {
}
break;
}
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/ay.cpp
View file

@ -635,6 +635,12 @@ int DivPlatformAY8910::dispatch(DivCommand c) {
sampleBank=parent->song.sample.size()/12;
}
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/ay8930.cpp
View file

@ -635,6 +635,12 @@ int DivPlatformAY8930::dispatch(DivCommand c) {
sampleBank=parent->song.sample.size()/12;
}
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/bubsyswsg.cpp
View file

@ -238,6 +238,12 @@ int DivPlatformBubSysWSG::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 15;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/c64.cpp
View file

@ -416,6 +416,12 @@ int DivPlatformC64::dispatch(DivCommand c) {
break;
}
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/fds.cpp
View file

@ -379,6 +379,12 @@ int DivPlatformFDS::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 32;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/ga20.cpp
View file

@ -301,6 +301,12 @@ int DivPlatformGA20::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 255;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/gb.cpp
View file

@ -529,6 +529,12 @@ int DivPlatformGB::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 15;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/genesis.cpp
View file

@ -1057,6 +1057,12 @@ int DivPlatformGenesis::dispatch(DivCommand c) {
if (c.chan>=6) break;
chan[c.chan].hardReset=c.value;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/genesisext.cpp
View file

@ -387,6 +387,12 @@ int DivPlatformGenesisExt::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 127;
break;
case DIV_CMD_MACRO_OFF:
opChan[ch].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
opChan[ch].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/k007232.cpp
View file

@ -379,6 +379,12 @@ int DivPlatformK007232::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 15;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/lynx.cpp
View file

@ -371,6 +371,12 @@ int DivPlatformLynx::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 127;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/mmc5.cpp
View file

@ -316,6 +316,12 @@ int DivPlatformMMC5::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 15;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/msm5232.cpp
View file

@ -274,6 +274,12 @@ int DivPlatformMSM5232::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 127;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/msm6258.cpp
View file

@ -241,6 +241,12 @@ int DivPlatformMSM6258::dispatch(DivCommand c) {
case DIV_CMD_LEGATO: {
break;
}
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/msm6295.cpp
View file

@ -221,6 +221,12 @@ int DivPlatformMSM6295::dispatch(DivCommand c) {
case DIV_CMD_LEGATO: {
break;
}
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/n163.cpp
View file

@ -514,6 +514,12 @@ int DivPlatformN163::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 15;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/namcowsg.cpp
View file

@ -427,6 +427,12 @@ int DivPlatformNamcoWSG::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 15;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/nes.cpp
View file

@ -564,6 +564,12 @@ int DivPlatformNES::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 15;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/opl.cpp
View file

@ -1352,6 +1352,12 @@ int DivPlatformOPL::dispatch(DivCommand c) {
if (c.chan==adpcmChan) break;
chan[c.chan].hardReset=c.value;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/opll.cpp
View file

@ -753,6 +753,12 @@ int DivPlatformOPLL::dispatch(DivCommand c) {
drumState=0;
}
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/pce.cpp
View file

@ -456,6 +456,12 @@ int DivPlatformPCE::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 31;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

340
src/engine/platform/pcmdac.cpp
View file

@ -29,92 +29,92 @@ void DivPlatformPCMDAC::acquire(short* bufL, short* bufR, size_t start, size_t l
const int depthScale=(15-outDepth);
int output=0;
for (size_t h=start; h<start+len; h++) {
if (!chan.active || isMuted) {
if (!chan[0].active || isMuted) {
bufL[h]=0;
bufR[h]=0;
oscBuf->data[oscBuf->needle++]=0;
continue;
}
if (chan.useWave || (chan.sample>=0 && chan.sample<parent->song.sampleLen)) {
chan.audPos+=((!chan.useWave) && chan.audDir)?-(chan.freq>>16):(chan.freq>>16);
chan.audSub+=(chan.freq&0xffff);
if (chan.audSub>=0x10000) {
chan.audSub-=0x10000;
chan.audPos+=((!chan.useWave) && chan.audDir)?-1:1;
if (chan[0].useWave || (chan[0].sample>=0 && chan[0].sample<parent->song.sampleLen)) {
chan[0].audPos+=((!chan[0].useWave) && chan[0].audDir)?-(chan[0].freq>>16):(chan[0].freq>>16);
chan[0].audSub+=(chan[0].freq&0xffff);
if (chan[0].audSub>=0x10000) {
chan[0].audSub-=0x10000;
chan[0].audPos+=((!chan[0].useWave) && chan[0].audDir)?-1:1;
}
if (chan.useWave) {
if (chan.audPos>=(int)chan.audLen) {
chan.audPos%=chan.audLen;
chan.audDir=false;
if (chan[0].useWave) {
if (chan[0].audPos>=(int)chan[0].audLen) {
chan[0].audPos%=chan[0].audLen;
chan[0].audDir=false;
}
output=(chan.ws.output[chan.audPos]-0x80)<<8;
output=(chan[0].ws.output[chan[0].audPos]-0x80)<<8;
} else {
DivSample* s=parent->getSample(chan.sample);
DivSample* s=parent->getSample(chan[0].sample);
if (s->samples>0) {
if (chan.audDir) {
if (chan[0].audDir) {
if (s->isLoopable()) {
switch (s->loopMode) {
case DIV_SAMPLE_LOOP_FORWARD:
case DIV_SAMPLE_LOOP_PINGPONG:
if (chan.audPos<s->loopStart) {
chan.audPos=s->loopStart+(s->loopStart-chan.audPos);
chan.audDir=false;
if (chan[0].audPos<s->loopStart) {
chan[0].audPos=s->loopStart+(s->loopStart-chan[0].audPos);
chan[0].audDir=false;
}
break;
case DIV_SAMPLE_LOOP_BACKWARD:
if (chan.audPos<s->loopStart) {
chan.audPos=s->loopEnd-1-(s->loopStart-chan.audPos);
chan.audDir=true;
if (chan[0].audPos<s->loopStart) {
chan[0].audPos=s->loopEnd-1-(s->loopStart-chan[0].audPos);
chan[0].audDir=true;
}
break;
default:
if (chan.audPos<0) {
chan.sample=-1;
if (chan[0].audPos<0) {
chan[0].sample=-1;
}
break;
}
} else if (chan.audPos>=(int)s->samples) {
chan.sample=-1;
} else if (chan[0].audPos>=(int)s->samples) {
chan[0].sample=-1;
}
} else {
if (s->isLoopable()) {
switch (s->loopMode) {
case DIV_SAMPLE_LOOP_FORWARD:
if (chan.audPos>=s->loopEnd) {
chan.audPos=(chan.audPos+s->loopStart)-s->loopEnd;
chan.audDir=false;
if (chan[0].audPos>=s->loopEnd) {
chan[0].audPos=(chan[0].audPos+s->loopStart)-s->loopEnd;
chan[0].audDir=false;
}
break;
case DIV_SAMPLE_LOOP_BACKWARD:
case DIV_SAMPLE_LOOP_PINGPONG:
if (chan.audPos>=s->loopEnd) {
chan.audPos=s->loopEnd-1-(s->loopEnd-1-chan.audPos);
chan.audDir=true;
if (chan[0].audPos>=s->loopEnd) {
chan[0].audPos=s->loopEnd-1-(s->loopEnd-1-chan[0].audPos);
chan[0].audDir=true;
}
break;
default:
if (chan.audPos>=(int)s->samples) {
chan.sample=-1;
if (chan[0].audPos>=(int)s->samples) {
chan[0].sample=-1;
}
break;
}
} else if (chan.audPos>=(int)s->samples) {
chan.sample=-1;
} else if (chan[0].audPos>=(int)s->samples) {
chan[0].sample=-1;
}
}
if (chan.audPos>=0 && chan.audPos<(int)s->samples) {
output=s->data16[chan.audPos];
if (chan[0].audPos>=0 && chan[0].audPos<(int)s->samples) {
output=s->data16[chan[0].audPos];
}
} else {
chan.sample=-1;
chan[0].sample=-1;
}
}
}
output=output*chan.vol*chan.envVol/16384;
output=output*chan[0].vol*chan[0].envVol/16384;
oscBuf->data[oscBuf->needle++]=output;
if (outStereo) {
bufL[h]=((output*chan.panL)>>(depthScale+8))<<depthScale;
bufR[h]=((output*chan.panR)>>(depthScale+8))<<depthScale;
bufL[h]=((output*chan[0].panL)>>(depthScale+8))<<depthScale;
bufR[h]=((output*chan[0].panR)>>(depthScale+8))<<depthScale;
} else {
output=(output>>depthScale)<<depthScale;
bufL[h]=output;
@ -124,204 +124,210 @@ void DivPlatformPCMDAC::acquire(short* bufL, short* bufR, size_t start, size_t l
}
void DivPlatformPCMDAC::tick(bool sysTick) {
chan.std.next();
if (chan.std.vol.had) {
chan.envVol=chan.std.vol.val;
chan[0].std.next();
if (chan[0].std.vol.had) {
chan[0].envVol=chan[0].std.vol.val;
}
if (chan.std.arp.had) {
if (!chan.inPorta) {
chan.baseFreq=NOTE_FREQUENCY(parent->calcArp(chan.note,chan.std.arp.val));
if (chan[0].std.arp.had) {
if (!chan[0].inPorta) {
chan[0].baseFreq=NOTE_FREQUENCY(parent->calcArp(chan[0].note,chan[0].std.arp.val));
}
chan.freqChanged=true;
chan[0].freqChanged=true;
}
if (chan.useWave && chan.std.wave.had) {
if (chan.wave!=chan.std.wave.val || chan.ws.activeChanged()) {
chan.wave=chan.std.wave.val;
chan.ws.changeWave1(chan.wave);
if (!chan.keyOff) chan.keyOn=true;
if (chan[0].useWave && chan[0].std.wave.had) {
if (chan[0].wave!=chan[0].std.wave.val || chan[0].ws.activeChanged()) {
chan[0].wave=chan[0].std.wave.val;
chan[0].ws.changeWave1(chan[0].wave);
if (!chan[0].keyOff) chan[0].keyOn=true;
}
}
if (chan.useWave && chan.active) {
chan.ws.tick();
if (chan[0].useWave && chan[0].active) {
chan[0].ws.tick();
}
if (chan.std.pitch.had) {
if (chan.std.pitch.mode) {
chan.pitch2+=chan.std.pitch.val;
CLAMP_VAR(chan.pitch2,-32768,32767);
if (chan[0].std.pitch.had) {
if (chan[0].std.pitch.mode) {
chan[0].pitch2+=chan[0].std.pitch.val;
CLAMP_VAR(chan[0].pitch2,-32768,32767);
} else {
chan.pitch2=chan.std.pitch.val;
chan[0].pitch2=chan[0].std.pitch.val;
}
chan.freqChanged=true;
chan[0].freqChanged=true;
}
if (chan.std.panL.had) {
int val=chan.std.panL.val&0x7f;
chan.panL=val*2;
if (chan[0].std.panL.had) {
int val=chan[0].std.panL.val&0x7f;
chan[0].panL=val*2;
}
if (chan.std.panR.had) {
int val=chan.std.panR.val&0x7f;
chan.panR=val*2;
if (chan[0].std.panR.had) {
int val=chan[0].std.panR.val&0x7f;
chan[0].panR=val*2;
}
if (chan.std.phaseReset.had) {
if (chan.std.phaseReset.val==1) {
chan.audDir=false;
chan.audPos=0;
if (chan[0].std.phaseReset.had) {
if (chan[0].std.phaseReset.val==1) {
chan[0].audDir=false;
chan[0].audPos=0;
}
}
if (chan.freqChanged || chan.keyOn || chan.keyOff) {
//DivInstrument* ins=parent->getIns(chan.ins,DIV_INS_AMIGA);
if (chan[0].freqChanged || chan[0].keyOn || chan[0].keyOff) {
//DivInstrument* ins=parent->getIns(chan[0].ins,DIV_INS_AMIGA);
double off=1.0;
if (!chan.useWave && chan.sample>=0 && chan.sample<parent->song.sampleLen) {
DivSample* s=parent->getSample(chan.sample);
if (!chan[0].useWave && chan[0].sample>=0 && chan[0].sample<parent->song.sampleLen) {
DivSample* s=parent->getSample(chan[0].sample);
off=(s->centerRate>=1)?((double)s->centerRate/8363.0):1.0;
}
chan.freq=off*parent->calcFreq(chan.baseFreq,chan.pitch,false,2,chan.pitch2,chipClock,CHIP_FREQBASE);
if (chan.freq>16777215) chan.freq=16777215;
if (chan.keyOn) {
if (!chan.std.vol.had) {
chan.envVol=64;
chan[0].freq=off*parent->calcFreq(chan[0].baseFreq,chan[0].pitch,false,2,chan[0].pitch2,chipClock,CHIP_FREQBASE);
if (chan[0].freq>16777215) chan[0].freq=16777215;
if (chan[0].keyOn) {
if (!chan[0].std.vol.had) {
chan[0].envVol=64;
}
chan.keyOn=false;
chan[0].keyOn=false;
}
if (chan.keyOff) {
chan.keyOff=false;
if (chan[0].keyOff) {
chan[0].keyOff=false;
}
chan.freqChanged=false;
chan[0].freqChanged=false;
}
}
int DivPlatformPCMDAC::dispatch(DivCommand c) {
switch (c.cmd) {
case DIV_CMD_NOTE_ON: {
DivInstrument* ins=parent->getIns(chan.ins,DIV_INS_AMIGA);
DivInstrument* ins=parent->getIns(chan[0].ins,DIV_INS_AMIGA);
if (ins->amiga.useWave) {
chan.useWave=true;
chan.audLen=ins->amiga.waveLen+1;
if (chan.insChanged) {
if (chan.wave<0) {
chan.wave=0;
chan.ws.setWidth(chan.audLen);
chan.ws.changeWave1(chan.wave);
chan[0].useWave=true;
chan[0].audLen=ins->amiga.waveLen+1;
if (chan[0].insChanged) {
if (chan[0].wave<0) {
chan[0].wave=0;
chan[0].ws.setWidth(chan[0].audLen);
chan[0].ws.changeWave1(chan[0].wave);
}
}
} else {
chan.sample=ins->amiga.getSample(c.value);
chan.useWave=false;
chan[0].sample=ins->amiga.getSample(c.value);
chan[0].useWave=false;
}
if (c.value!=DIV_NOTE_NULL) {
chan.baseFreq=round(NOTE_FREQUENCY(c.value));
chan[0].baseFreq=round(NOTE_FREQUENCY(c.value));
}
if (chan.useWave || chan.sample<0 || chan.sample>=parent->song.sampleLen) {
chan.sample=-1;
if (chan[0].useWave || chan[0].sample<0 || chan[0].sample>=parent->song.sampleLen) {
chan[0].sample=-1;
}
if (chan.setPos) {
chan.setPos=false;
if (chan[0].setPos) {
chan[0].setPos=false;
} else {
chan.audDir=false;
chan.audPos=0;
chan[0].audDir=false;
chan[0].audPos=0;
}
chan.audSub=0;
chan[0].audSub=0;
if (c.value!=DIV_NOTE_NULL) {
chan.freqChanged=true;
chan.note=c.value;
chan[0].freqChanged=true;
chan[0].note=c.value;
}
chan.active=true;
chan.keyOn=true;
chan.macroInit(ins);
if (!parent->song.brokenOutVol && !chan.std.vol.will) {
chan.envVol=64;
chan[0].active=true;
chan[0].keyOn=true;
chan[0].macroInit(ins);
if (!parent->song.brokenOutVol && !chan[0].std.vol.will) {
chan[0].envVol=64;
}
if (chan.useWave) {
chan.ws.init(ins,chan.audLen,255,chan.insChanged);
if (chan[0].useWave) {
chan[0].ws.init(ins,chan[0].audLen,255,chan[0].insChanged);
}
chan.insChanged=false;
chan[0].insChanged=false;
break;
}
case DIV_CMD_NOTE_OFF:
chan.sample=-1;
chan.active=false;
chan.keyOff=true;
chan.macroInit(NULL);
chan[0].sample=-1;
chan[0].active=false;
chan[0].keyOff=true;
chan[0].macroInit(NULL);
break;
case DIV_CMD_NOTE_OFF_ENV:
case DIV_CMD_ENV_RELEASE:
chan.std.release();
chan[0].std.release();
break;
case DIV_CMD_INSTRUMENT:
if (chan.ins!=c.value || c.value2==1) {
chan.ins=c.value;
chan.insChanged=true;
if (chan[0].ins!=c.value || c.value2==1) {
chan[0].ins=c.value;
chan[0].insChanged=true;
}
break;
case DIV_CMD_VOLUME:
if (chan.vol!=c.value) {
chan.vol=c.value;
if (!chan.std.vol.has) {
chan.envVol=64;
if (chan[0].vol!=c.value) {
chan[0].vol=c.value;
if (!chan[0].std.vol.has) {
chan[0].envVol=64;
}
}
break;
case DIV_CMD_GET_VOLUME:
return chan.vol;
return chan[0].vol;
break;
case DIV_CMD_PANNING:
chan.panL=c.value;
chan.panR=c.value2;
chan[0].panL=c.value;
chan[0].panR=c.value2;
break;
case DIV_CMD_PITCH:
chan.pitch=c.value;
chan.freqChanged=true;
chan[0].pitch=c.value;
chan[0].freqChanged=true;
break;
case DIV_CMD_WAVE:
if (!chan.useWave) break;
chan.wave=c.value;
chan.keyOn=true;
chan.ws.changeWave1(chan.wave);
if (!chan[0].useWave) break;
chan[0].wave=c.value;
chan[0].keyOn=true;
chan[0].ws.changeWave1(chan[0].wave);
break;
case DIV_CMD_NOTE_PORTA: {
DivInstrument* ins=parent->getIns(chan.ins,DIV_INS_AMIGA);
chan.sample=ins->amiga.getSample(c.value2);
DivInstrument* ins=parent->getIns(chan[0].ins,DIV_INS_AMIGA);
chan[0].sample=ins->amiga.getSample(c.value2);
int destFreq=round(NOTE_FREQUENCY(c.value2));
bool return2=false;
if (destFreq>chan.baseFreq) {
chan.baseFreq+=c.value;
if (chan.baseFreq>=destFreq) {
chan.baseFreq=destFreq;
if (destFreq>chan[0].baseFreq) {
chan[0].baseFreq+=c.value;
if (chan[0].baseFreq>=destFreq) {
chan[0].baseFreq=destFreq;
return2=true;
}
} else {
chan.baseFreq-=c.value;
if (chan.baseFreq<=destFreq) {
chan.baseFreq=destFreq;
chan[0].baseFreq-=c.value;
if (chan[0].baseFreq<=destFreq) {
chan[0].baseFreq=destFreq;
return2=true;
}
}
chan.freqChanged=true;
chan[0].freqChanged=true;
if (return2) {
chan.inPorta=false;
chan[0].inPorta=false;
return 2;
}
break;
}
case DIV_CMD_LEGATO: {
chan.baseFreq=round(NOTE_FREQUENCY(c.value+((chan.std.arp.will && !chan.std.arp.mode)?(chan.std.arp.val):(0))));
chan.freqChanged=true;
chan.note=c.value;
chan[0].baseFreq=round(NOTE_FREQUENCY(c.value+((chan[0].std.arp.will && !chan[0].std.arp.mode)?(chan[0].std.arp.val):(0))));
chan[0].freqChanged=true;
chan[0].note=c.value;
break;
}
case DIV_CMD_PRE_PORTA:
if (chan.active && c.value2) {
if (parent->song.resetMacroOnPorta) chan.macroInit(parent->getIns(chan.ins,DIV_INS_AMIGA));
if (chan[0].active && c.value2) {
if (parent->song.resetMacroOnPorta) chan[0].macroInit(parent->getIns(chan[0].ins,DIV_INS_AMIGA));
}
chan.inPorta=c.value;
chan[0].inPorta=c.value;
break;
case DIV_CMD_SAMPLE_POS:
if (chan.useWave) break;
chan.audPos=c.value;
chan.setPos=true;
if (chan[0].useWave) break;
chan[0].audPos=c.value;
chan[0].setPos=true;
break;
case DIV_CMD_GET_VOLMAX:
return 255;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;
@ -336,11 +342,11 @@ void DivPlatformPCMDAC::muteChannel(int ch, bool mute) {
}
void DivPlatformPCMDAC::forceIns() {
chan.insChanged=true;
chan.freqChanged=true;
chan.audDir=false;
chan.audPos=0;
chan.sample=-1;
chan[0].insChanged=true;
chan[0].freqChanged=true;
chan[0].audDir=false;
chan[0].audPos=0;
chan[0].sample=-1;
}
void* DivPlatformPCMDAC::getChanState(int ch) {
@ -352,10 +358,10 @@ DivDispatchOscBuffer* DivPlatformPCMDAC::getOscBuffer(int ch) {
}
void DivPlatformPCMDAC::reset() {
chan=DivPlatformPCMDAC::Channel();
chan.std.setEngine(parent);
chan.ws.setEngine(parent);
chan.ws.init(NULL,32,255);
chan[0]=DivPlatformPCMDAC::Channel();
chan[0].std.setEngine(parent);
chan[0].ws.setEngine(parent);
chan[0].ws.init(NULL,32,255);
}
bool DivPlatformPCMDAC::isStereo() {
@ -363,23 +369,23 @@ bool DivPlatformPCMDAC::isStereo() {
}
DivMacroInt* DivPlatformPCMDAC::getChanMacroInt(int ch) {
return &chan.std;
return &chan[0].std;
}
void DivPlatformPCMDAC::notifyInsChange(int ins) {
if (chan.ins==ins) {
chan.insChanged=true;
if (chan[0].ins==ins) {
chan[0].insChanged=true;
}
}
void DivPlatformPCMDAC::notifyWaveChange(int wave) {
if (chan.useWave && chan.wave==wave) {
chan.ws.changeWave1(wave);
if (chan[0].useWave && chan[0].wave==wave) {
chan[0].ws.changeWave1(wave);
}
}
void DivPlatformPCMDAC::notifyInsDeletion(void* ins) {
chan.std.notifyInsDeletion((DivInstrument*)ins);
chan[0].std.notifyInsDeletion((DivInstrument*)ins);
}
void DivPlatformPCMDAC::setFlags(const DivConfig& flags) {

2
src/engine/platform/pcmdac.h
View file

@ -51,7 +51,7 @@ class DivPlatformPCMDAC: public DivDispatch {
setPos(false),
envVol(64) {}
};
Channel chan;
Channel chan[1];
DivDispatchOscBuffer* oscBuf;
bool isMuted;
int outDepth;

6
src/engine/platform/pcspkr.cpp
View file

@ -464,6 +464,12 @@ int DivPlatformPCSpeaker::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 1;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

192
src/engine/platform/pet.cpp
View file

@ -44,12 +44,12 @@ void DivPlatformPET::rWrite(unsigned int addr, unsigned char val) {
case 9:
// simulate phase reset from switching between hw/sw shift registers
if ((regPool[9]==0)^(val==0)) {
chan.sreg=chan.wave;
chan[0].sreg=chan[0].wave;
}
break;
case 10:
chan.sreg=val;
if (hwSROutput) chan.cnt=2;
chan[0].sreg=val;
if (hwSROutput) chan[0].cnt=2;
break;
}
regPool[addr]=val;
@ -57,27 +57,27 @@ void DivPlatformPET::rWrite(unsigned int addr, unsigned char val) {
void DivPlatformPET::acquire(short* bufL, short* bufR, size_t start, size_t len) {
bool hwSROutput=((regPool[11]>>2)&7)==4;
if (chan.enable) {
if (chan[0].enable) {
int reload=regPool[8]*2+4;
if (!hwSROutput) {
reload+=regPool[9]*512;
}
for (size_t h=start; h<start+len; h++) {
if (SAMP_DIVIDER>chan.cnt) {
chan.out=(chan.sreg&1)*32767;
chan.sreg=(chan.sreg>>1)|((chan.sreg&1)<<7);
chan.cnt+=reload-SAMP_DIVIDER;
if (SAMP_DIVIDER>chan[0].cnt) {
chan[0].out=(chan[0].sreg&1)*32767;
chan[0].sreg=(chan[0].sreg>>1)|((chan[0].sreg&1)<<7);
chan[0].cnt+=reload-SAMP_DIVIDER;
} else {
chan.cnt-=SAMP_DIVIDER;
chan[0].cnt-=SAMP_DIVIDER;
}
bufL[h]=chan.out;
bufR[h]=chan.out;
oscBuf->data[oscBuf->needle++]=chan.out;
bufL[h]=chan[0].out;
bufR[h]=chan[0].out;
oscBuf->data[oscBuf->needle++]=chan[0].out;
}
// emulate driver writes to PCR
if (!hwSROutput) regPool[12]=chan.out?0xe0:0xc0;
if (!hwSROutput) regPool[12]=chan[0].out?0xe0:0xc0;
} else {
chan.out=0;
chan[0].out=0;
for (size_t h=start; h<start+len; h++) {
bufL[h]=0;
bufR[h]=0;
@ -87,152 +87,158 @@ void DivPlatformPET::acquire(short* bufL, short* bufR, size_t start, size_t len)
}
void DivPlatformPET::writeOutVol() {
if (chan.active && !isMuted && chan.outVol>0) {
chan.enable=true;
if (chan[0].active && !isMuted && chan[0].outVol>0) {
chan[0].enable=true;
rWrite(11,regPool[9]==0?16:0);
} else {
chan.enable=false;
chan[0].enable=false;
rWrite(11,0);
}
}
void DivPlatformPET::tick(bool sysTick) {
chan.std.next();
if (chan.std.vol.had) {
chan.outVol=chan.std.vol.val&chan.vol;
chan[0].std.next();
if (chan[0].std.vol.had) {
chan[0].outVol=chan[0].std.vol.val&chan[0].vol;
writeOutVol();
}
if (chan.std.arp.had) {
if (!chan.inPorta) {
chan.baseFreq=NOTE_PERIODIC(parent->calcArp(chan.note,chan.std.arp.val));
if (chan[0].std.arp.had) {
if (!chan[0].inPorta) {
chan[0].baseFreq=NOTE_PERIODIC(parent->calcArp(chan[0].note,chan[0].std.arp.val));
}
chan.freqChanged=true;
chan[0].freqChanged=true;
}
if (chan.std.wave.had) {
if (chan.wave!=chan.std.wave.val) {
chan.wave=chan.std.wave.val;
rWrite(10,chan.wave);
if (chan[0].std.wave.had) {
if (chan[0].wave!=chan[0].std.wave.val) {
chan[0].wave=chan[0].std.wave.val;
rWrite(10,chan[0].wave);
}
}
if (chan.std.pitch.had) {
if (chan.std.pitch.mode) {
chan.pitch2+=chan.std.pitch.val;
CLAMP_VAR(chan.pitch2,-32768,32767);
if (chan[0].std.pitch.had) {
if (chan[0].std.pitch.mode) {
chan[0].pitch2+=chan[0].std.pitch.val;
CLAMP_VAR(chan[0].pitch2,-32768,32767);
} else {
chan.pitch2=chan.std.pitch.val;
chan[0].pitch2=chan[0].std.pitch.val;
}
chan.freqChanged=true;
chan[0].freqChanged=true;
}
if (chan.freqChanged || chan.keyOn || chan.keyOff) {
chan.freq=parent->calcFreq(chan.baseFreq,chan.pitch,true,0,chan.pitch2,chipClock,CHIP_DIVIDER)-2;
if (chan.freq>65535) chan.freq=65535;
if (chan.freq<0) chan.freq=0;
rWrite(8,chan.freq&0xff);
rWrite(9,chan.freq>>8);
if (chan.keyOn) {
if (!chan.std.vol.will) {
chan.outVol=chan.vol;
if (chan[0].freqChanged || chan[0].keyOn || chan[0].keyOff) {
chan[0].freq=parent->calcFreq(chan[0].baseFreq,chan[0].pitch,true,0,chan[0].pitch2,chipClock,CHIP_DIVIDER)-2;
if (chan[0].freq>65535) chan[0].freq=65535;
if (chan[0].freq<0) chan[0].freq=0;
rWrite(8,chan[0].freq&0xff);
rWrite(9,chan[0].freq>>8);
if (chan[0].keyOn) {
if (!chan[0].std.vol.will) {
chan[0].outVol=chan[0].vol;
}
chan.keyOn=false;
chan[0].keyOn=false;
}
if (chan.keyOff) {
chan.keyOff=false;
if (chan[0].keyOff) {
chan[0].keyOff=false;
}
// update mode setting and channel enable
writeOutVol();
chan.freqChanged=false;
chan[0].freqChanged=false;
}
}
int DivPlatformPET::dispatch(DivCommand c) {
switch (c.cmd) {
case DIV_CMD_NOTE_ON: {
DivInstrument* ins=parent->getIns(chan.ins,DIV_INS_PET);
DivInstrument* ins=parent->getIns(chan[0].ins,DIV_INS_PET);
if (c.value!=DIV_NOTE_NULL) {
chan.baseFreq=NOTE_PERIODIC(c.value);
chan.freqChanged=true;
chan.note=c.value;
chan[0].baseFreq=NOTE_PERIODIC(c.value);
chan[0].freqChanged=true;
chan[0].note=c.value;
}
chan.active=true;
chan.keyOn=true;
chan.macroInit(ins);
if (!parent->song.brokenOutVol && !chan.std.vol.will) {
chan.outVol=chan.vol;
chan[0].active=true;
chan[0].keyOn=true;
chan[0].macroInit(ins);
if (!parent->song.brokenOutVol && !chan[0].std.vol.will) {
chan[0].outVol=chan[0].vol;
}
break;
}
case DIV_CMD_NOTE_OFF:
chan.active=false;
chan.keyOff=true;
chan.macroInit(NULL);
chan[0].active=false;
chan[0].keyOff=true;
chan[0].macroInit(NULL);
break;
case DIV_CMD_NOTE_OFF_ENV:
case DIV_CMD_ENV_RELEASE:
chan.std.release();
chan[0].std.release();
break;
case DIV_CMD_INSTRUMENT:
if (chan.ins!=c.value || c.value2==1) {
chan.ins=c.value;
if (chan[0].ins!=c.value || c.value2==1) {
chan[0].ins=c.value;
}
break;
case DIV_CMD_VOLUME:
if (chan.vol!=c.value) {
chan.vol=c.value;
if (!chan.std.vol.had) {
chan.outVol=chan.vol;
if (chan[0].vol!=c.value) {
chan[0].vol=c.value;
if (!chan[0].std.vol.had) {
chan[0].outVol=chan[0].vol;
writeOutVol();
}
}
break;
case DIV_CMD_GET_VOLUME:
return chan.vol;
return chan[0].vol;
break;
case DIV_CMD_PITCH:
chan.pitch=c.value;
chan.freqChanged=true;
chan[0].pitch=c.value;
chan[0].freqChanged=true;
break;
case DIV_CMD_WAVE:
chan.wave=c.value;
rWrite(10,chan.wave);
chan[0].wave=c.value;
rWrite(10,chan[0].wave);
break;
case DIV_CMD_NOTE_PORTA: {
int destFreq=NOTE_PERIODIC(c.value2);
bool return2=false;
if (destFreq>chan.baseFreq) {
chan.baseFreq+=c.value;
if (chan.baseFreq>=destFreq) {
chan.baseFreq=destFreq;
if (destFreq>chan[0].baseFreq) {
chan[0].baseFreq+=c.value;
if (chan[0].baseFreq>=destFreq) {
chan[0].baseFreq=destFreq;
return2=true;
}
} else {
chan.baseFreq-=c.value;
if (chan.baseFreq<=destFreq) {
chan.baseFreq=destFreq;
chan[0].baseFreq-=c.value;
if (chan[0].baseFreq<=destFreq) {
chan[0].baseFreq=destFreq;
return2=true;
}
}
chan.freqChanged=true;
chan[0].freqChanged=true;
if (return2) {
chan.inPorta=false;
chan[0].inPorta=false;
return 2;
}
break;
}
case DIV_CMD_LEGATO:
chan.baseFreq=NOTE_PERIODIC(c.value+((chan.std.arp.will && !chan.std.arp.mode)?(chan.std.arp.val):(0)));
chan.freqChanged=true;
chan.note=c.value;
chan[0].baseFreq=NOTE_PERIODIC(c.value+((chan[0].std.arp.will && !chan[0].std.arp.mode)?(chan[0].std.arp.val):(0)));
chan[0].freqChanged=true;
chan[0].note=c.value;
break;
case DIV_CMD_PRE_PORTA:
if (chan.active && c.value2) {
if (parent->song.resetMacroOnPorta) chan.macroInit(parent->getIns(chan.ins,DIV_INS_PET));
if (chan[0].active && c.value2) {
if (parent->song.resetMacroOnPorta) chan[0].macroInit(parent->getIns(chan[0].ins,DIV_INS_PET));
}
if (!chan.inPorta && c.value && !parent->song.brokenPortaArp && chan.std.arp.will) chan.baseFreq=NOTE_PERIODIC(chan.note);
chan.inPorta=c.value;
if (!chan[0].inPorta && c.value && !parent->song.brokenPortaArp && chan[0].std.arp.will) chan[0].baseFreq=NOTE_PERIODIC(chan[0].note);
chan[0].inPorta=c.value;
break;
case DIV_CMD_GET_VOLMAX:
return 1;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;
@ -248,8 +254,8 @@ void DivPlatformPET::muteChannel(int ch, bool mute) {
}
void DivPlatformPET::forceIns() {
chan.insChanged=true;
chan.freqChanged=true;
chan[0].insChanged=true;
chan[0].freqChanged=true;
writeOutVol();
}
@ -258,7 +264,7 @@ void* DivPlatformPET::getChanState(int ch) {
}
DivMacroInt* DivPlatformPET::getChanMacroInt(int ch) {
return &chan.std;
return &chan[0].std;
}
DivDispatchOscBuffer* DivPlatformPET::getOscBuffer(int ch) {
@ -275,8 +281,8 @@ int DivPlatformPET::getRegisterPoolSize() {
void DivPlatformPET::reset() {
memset(regPool,0,16);
chan=Channel();
chan.std.setEngine(parent);
chan[0]=Channel();
chan[0].std.setEngine(parent);
}
bool DivPlatformPET::isStereo() {
@ -284,7 +290,7 @@ bool DivPlatformPET::isStereo() {
}
void DivPlatformPET::notifyInsDeletion(void* ins) {
chan.std.notifyInsDeletion((DivInstrument*)ins);
chan[0].std.notifyInsDeletion((DivInstrument*)ins);
}
void DivPlatformPET::poke(unsigned int addr, unsigned short val) {

2
src/engine/platform/pet.h
View file

@ -37,7 +37,7 @@ class DivPlatformPET: public DivDispatch {
cnt(0),
out(0) {}
};
Channel chan;
Channel chan[1];
DivDispatchOscBuffer* oscBuf;
bool isMuted;

6
src/engine/platform/pokemini.cpp
View file

@ -199,6 +199,12 @@ int DivPlatformPokeMini::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 2;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/pong.cpp
View file

@ -172,6 +172,12 @@ int DivPlatformPong::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 1;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/qsound.cpp
View file

@ -573,6 +573,12 @@ int DivPlatformQSound::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 255;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/rf5c68.cpp
View file

@ -273,6 +273,12 @@ int DivPlatformRF5C68::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 255;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/saa.cpp
View file

@ -308,6 +308,12 @@ int DivPlatformSAA1099::dispatch(DivCommand c) {
saaEnv[c.chan/3]=c.value;
rWrite(0x18+(c.chan/3),c.value);
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/scc.cpp
View file

@ -255,6 +255,12 @@ int DivPlatformSCC::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 15;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/segapcm.cpp
View file

@ -358,6 +358,12 @@ int DivPlatformSegaPCM::dispatch(DivCommand c) {
sampleBank=parent->song.sample.size()/12;
}
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/sms.cpp
View file

@ -378,6 +378,12 @@ int DivPlatformSMS::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 15;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/snes.cpp
View file

@ -561,6 +561,12 @@ int DivPlatformSNES::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 127;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
default:
break;
}

6
src/engine/platform/su.cpp
View file

@ -412,6 +412,12 @@ int DivPlatformSoundUnit::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 127;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/swan.cpp
View file

@ -406,6 +406,12 @@ int DivPlatformSwan::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 15;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/t6w28.cpp
View file

@ -262,6 +262,12 @@ int DivPlatformT6W28::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 15;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/tia.cpp
View file

@ -253,6 +253,12 @@ int DivPlatformTIA::dispatch(DivCommand c) {
rWrite(0x15+c.chan,chan[c.chan].shape);
chan[c.chan].freqChanged=true;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

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

@ -784,6 +784,12 @@ int DivPlatformTX81Z::dispatch(DivCommand c) {
}
break;
}
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/vb.cpp
View file

@ -380,6 +380,12 @@ int DivPlatformVB::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 15;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/vera.cpp
View file

@ -356,6 +356,12 @@ int DivPlatformVERA::dispatch(DivCommand c) {
return 15;
}
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/vic20.cpp
View file

@ -231,6 +231,12 @@ int DivPlatformVIC20::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 15;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/vrc6.cpp
View file

@ -403,6 +403,12 @@ int DivPlatformVRC6::dispatch(DivCommand c) {
if (c.chan==2) return 63; // sawtooth has 6 bit volume
return 15; // pulse has 4 bit volume
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/x1_010.cpp
View file

@ -819,6 +819,12 @@ int DivPlatformX1_010::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 15;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/ym2203.cpp
View file

@ -729,6 +729,12 @@ int DivPlatformYM2203::dispatch(DivCommand c) {
case DIV_CMD_FM_HARD_RESET:
chan[c.chan].hardReset=c.value;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/ym2203ext.cpp
View file

@ -317,6 +317,12 @@ int DivPlatformYM2203Ext::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 127;
break;
case DIV_CMD_MACRO_OFF:
opChan[ch].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
opChan[ch].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/ym2608.cpp
View file

@ -1123,6 +1123,12 @@ int DivPlatformYM2608::dispatch(DivCommand c) {
case DIV_CMD_FM_HARD_RESET:
chan[c.chan].hardReset=c.value;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/ym2608ext.cpp
View file

@ -334,6 +334,12 @@ int DivPlatformYM2608Ext::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 127;
break;
case DIV_CMD_MACRO_OFF:
opChan[ch].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
opChan[ch].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/ym2610.cpp
View file

@ -1103,6 +1103,12 @@ int DivPlatformYM2610::dispatch(DivCommand c) {
case DIV_CMD_FM_HARD_RESET:
chan[c.chan].hardReset=c.value;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/ym2610b.cpp
View file

@ -1166,6 +1166,12 @@ int DivPlatformYM2610B::dispatch(DivCommand c) {
case DIV_CMD_FM_HARD_RESET:
chan[c.chan].hardReset=c.value;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/ym2610bext.cpp
View file

@ -330,6 +330,12 @@ int DivPlatformYM2610BExt::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 127;
break;
case DIV_CMD_MACRO_OFF:
opChan[ch].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
opChan[ch].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/ym2610ext.cpp
View file

@ -330,6 +330,12 @@ int DivPlatformYM2610Ext::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 127;
break;
case DIV_CMD_MACRO_OFF:
opChan[ch].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
opChan[ch].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 0;
break;

6
src/engine/platform/ymz280b.cpp
View file

@ -311,6 +311,12 @@ int DivPlatformYMZ280B::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 255;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;

6
src/engine/platform/zxbeeper.cpp
View file

@ -209,6 +209,12 @@ int DivPlatformZXBeeper::dispatch(DivCommand c) {
case DIV_CMD_GET_VOLMAX:
return 1;
break;
case DIV_CMD_MACRO_OFF:
chan[c.chan].std.mask(c.value,true);
break;
case DIV_CMD_MACRO_ON:
chan[c.chan].std.mask(c.value,false);
break;
case DIV_ALWAYS_SET_VOLUME:
return 1;
break;