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

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
Show stats Download patch file Download diff file Expand all files Collapse all files

72
papers/doc/3-pattern/effects.md
View file

@ -65,6 +65,9 @@ however, effects are continuous, which means you only need to type it once and t
- `F2xx`: single tick slide down.
- `F3xx`: fine volume slide up (64x slower than `0Axy`).
- `F4xx`: fine volume slide down (64x slower than `0Axy`).
- `F5xx`: disable macro.
- see macro table at the end of this document for possible values.
- `F6xx`: enable macro.
- `F8xx`: single tick volume slide up.
- `F9xx`: single tick volume slide down.
- `FAxy`: fast volume slide (4x faster than `0Axy`).
@ -73,3 +76,72 @@ however, effects are continuous, which means you only need to type it once and t
- `FFxx`: end of song/stop playback.
additionally each chip has its own effects. [click here for more details](../7-systems/README.md).
## macro table
ID | macro
---|-----------------------------
00 | volume
01 | arpeggio
02 | duty/noise
03 | waveform
04 | pitch
05 | extra 1
06 | extra 2
07 | extra 3
08 | extra A (ALG)
09 | extra B (FM)
0A | extra C (FMS)
0B | extra D (AMS)
0C | panning left
0D | panning right
0E | phase reset
0F | extra 4
10 | extra 5
11 | extra 6
12 | extra 7
13 | extra 8
---|-----------------------------
20 | **operator 1 macros** - AM
21 | AR
22 | DR
23 | MULT
24 | RR
25 | SL
26 | TL
27 | DT2
28 | RS
29 | DT
2A | D2R
2B | SSG-EG
2C | DAM
2D | DVB
2E | EGT
2F | KSL
30 | SUS
31 | VIB
32 | WS
33 | KSR
---|-----------------------------
40 | operator 2 macros
60 | operator 2 macros
80 | operator 2 macros
the interpretation of duty, wave and extra macros depends on chip/instrument type:
ex | FM | OPM | OPZ | OPLL | AY-3-8910 | AY8930 | Lynx | C64 | SAA1099 | X1-010 | Namco 163 | FDS | Sound Unit | ES5506 | MSM6258 | QSound | SNES | MSM5232 |
---|--------|-----------|-----------|-------|------------|------------|----------|------------|----------|------------|------------|-----------|------------|-----------|----------|--------------|-----------|-----------|
D | NoiseF | NoiseFreq | | | NoiseFreq | NoiseFreq | Duty/Int | Duty | | | Wave Pos | | Duty | Filt Mode | FreqDiv | Echo Level | NoiseFreq | GroupCtrl |
W | | LFO Shape | LFO Shape | Patch | Waveform | Waveform | | Waveform | Waveform | Waveform | Waveform | Waveform | Waveform | | | | Waveform | |
1 | | AMD | AMD | | | Duty | | FilterMode | Envelope | EnvMode | WaveLen | Mod Depth | Cutoff | Filter K1 | ClockDiv | EchoFeedback | Special | GroupAtk |
2 | | PMD | PMD | | Envelope | Envelope | | Resonance | | Envelope | WaveUpdate | Mod Speed | Resonance | Filter K2 | | Echo Length | Gain | GroupDec |
3 | | LFO Speed | LFO Speed | | AutoEnvNum | AutoEnvNum | | Special | | AutoEnvNum | WaveLoad W | | Control | Env Count | | | | Noise |
A | ALG | ALG | ALG | | AutoEnvDen | AutoEnvDen | | | | AutoEnvDen | WaveLoad P | | | Control | | | | |
B | FB | FB | FB | | | Noise AND | | | | | WaveLoad L | | | | | | | |
C | FMS | FMS | FMS | | | Noise OR | | | | | WaveLoad T | | | | | | | |
D | AMS | AMS | AMS | | | | | | | | | | | | | | | |
4 | OpMask | OpMask | | | | | | Test/Gate | | | | | PResetTime | EnvRampL | | | | |
5 | | | AMD2 | | | | | | | | | | | EnvRampR | | | | |
6 | | | PMD2 | | | | | | | | | | | EnvRampK1 | | | | |
7 | | | LFO2Speed | | | | | | | | | | | EnvRampK2 | | | | |
8 | | | LFO2Shape | | | | | | | | | | | Env Mode | | | | |

3
src/engine/dispatch.h
View file

@ -210,6 +210,9 @@ enum DivDispatchCmds {
DIV_CMD_NES_LENGTH,
DIV_CMD_NES_COUNT_MODE,
DIV_CMD_MACRO_OFF, // (which)
DIV_CMD_MACRO_ON, // (which)
DIV_ALWAYS_SET_VOLUME, // () -> alwaysSetVol
DIV_CMD_MAX

6
src/engine/engine.cpp
View file

@ -113,6 +113,10 @@ const char* DivEngine::getEffectDesc(unsigned char effect, int chan, bool notNul
return "F3xx: Fine volume slide up";
case 0xf4:
return "F4xx: Fine volume slide down";
case 0xf5:
return "F5xx: Disable macro (see manual)";
case 0xf6:
return "F6xx: Enable macro (see manual)";
case 0xf8:
return "F8xx: Single tick volume slide up";
case 0xf9:
@ -405,6 +409,8 @@ void writePackedCommandValues(SafeWriter* w, const DivCommand& c) {
case DIV_CMD_AMIGA_FILTER:
case DIV_CMD_AMIGA_AM:
case DIV_CMD_AMIGA_PM:
case DIV_CMD_MACRO_OFF:
case DIV_CMD_MACRO_ON:
w->writeC(1); // length
w->writeC(c.value);
break;

66
src/engine/macroInt.cpp
View file

@ -50,6 +50,10 @@ void DivMacroStruct::doMacro(DivInstrumentMacro& source, bool released, bool tic
had=false;
return;
}
if (masked) {
had=false;
return;
}
if (delay>0) {
delay--;
had=false;
@ -173,6 +177,66 @@ void DivMacroInt::next() {
}
}
#define CONSIDER(x,y) \
case y: \
x.masked=enabled; \
break;
#define CONSIDER_OP(oi,o) \
CONSIDER(op[oi].am,0+o) \
CONSIDER(op[oi].ar,1+o) \
CONSIDER(op[oi].dr,2+o) \
CONSIDER(op[oi].mult,3+o) \
CONSIDER(op[oi].rr,4+o) \
CONSIDER(op[oi].sl,5+o) \
CONSIDER(op[oi].tl,6+o) \
CONSIDER(op[oi].dt2,7+o) \
CONSIDER(op[oi].rs,8+o) \
CONSIDER(op[oi].dt,9+o) \
CONSIDER(op[oi].d2r,10+o) \
CONSIDER(op[oi].ssg,11+o) \
CONSIDER(op[oi].dam,12+o) \
CONSIDER(op[oi].dvb,13+o) \
CONSIDER(op[oi].egt,14+o) \
CONSIDER(op[oi].ksl,15+o) \
CONSIDER(op[oi].sus,16+o) \
CONSIDER(op[oi].vib,17+o) \
CONSIDER(op[oi].ws,18+o) \
CONSIDER(op[oi].ksr,19+o)
void DivMacroInt::mask(unsigned char id, bool enabled) {
switch (id) {
CONSIDER(vol,0)
CONSIDER(arp,1)
CONSIDER(duty,2)
CONSIDER(wave,3)
CONSIDER(pitch,4)
CONSIDER(ex1,5)
CONSIDER(ex2,6)
CONSIDER(ex3,7)
CONSIDER(alg,8)
CONSIDER(fb,9)
CONSIDER(fms,10)
CONSIDER(ams,11)
CONSIDER(panL,12)
CONSIDER(panR,13)
CONSIDER(phaseReset,14)
CONSIDER(ex4,15)
CONSIDER(ex5,16)
CONSIDER(ex6,17)
CONSIDER(ex7,18)
CONSIDER(ex8,19)
CONSIDER_OP(0,0x20)
CONSIDER_OP(2,0x40)
CONSIDER_OP(1,0x60)
CONSIDER_OP(3,0x80)
}
}
#undef CONSIDER_OP
#undef CONSIDER
void DivMacroInt::release() {
released=true;
}
@ -458,3 +522,5 @@ DivMacroStruct* DivMacroInt::structByName(const String& name) {
return NULL;
}
#undef CONSIDER

8
src/engine/macroInt.h
View file

@ -27,7 +27,7 @@ class DivEngine;
struct DivMacroStruct {
int pos, lastPos, lfoPos, delay;
int val;
bool has, had, actualHad, finished, will, linger, began;
bool has, had, actualHad, finished, will, linger, began, masked;
unsigned int mode, type;
void doMacro(DivInstrumentMacro& source, bool released, bool tick);
void init() {
@ -52,6 +52,7 @@ struct DivMacroStruct {
will(false),
linger(false),
began(true),
masked(false),
mode(0),
type(0) {}
};
@ -105,6 +106,11 @@ class DivMacroInt {
// state
bool hasRelease;
/**
* set mask on macro.
*/
void mask(unsigned char id, bool enabled);
/**
* trigger macro release.
*/

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;

15
src/engine/playback.cpp
View file

@ -206,9 +206,12 @@ const char* cmdName[]={
"SNES_ECHO_FEEDBACK",
"SNES_ECHO_FIR",
"DIV_CMD_NES_ENV_MODE",
"DIV_CMD_NES_LENGTH",
"DIV_CMD_NES_COUNT_MODE",
"NES_ENV_MODE",
"NES_LENGTH",
"NES_COUNT_MODE",
"MACRO_OFF",
"MACRO_ON",
"ALWAYS_SET_VOLUME"
};
@ -824,6 +827,12 @@ void DivEngine::processRow(int i, bool afterDelay) {
chan[i].volSpeed=-effectVal;
dispatchCmd(DivCommand(DIV_CMD_HINT_VOL_SLIDE,i,chan[i].volSpeed));
break;
case 0xf5: // disable macro
dispatchCmd(DivCommand(DIV_CMD_MACRO_OFF,i,effectVal&0xff));
break;
case 0xf6: // enable macro
dispatchCmd(DivCommand(DIV_CMD_MACRO_ON,i,effectVal&0xff));
break;
case 0xf8: // single volume ramp up
chan[i].volume=MIN(chan[i].volume+effectVal*256,chan[i].volMax);
dispatchCmd(DivCommand(DIV_CMD_VOLUME,i,chan[i].volume>>8));

4
src/gui/guiConst.cpp
View file

@ -440,8 +440,8 @@ const FurnaceGUIColors fxColors[256]={
GUI_COLOR_PATTERN_EFFECT_PITCH, // F2
GUI_COLOR_PATTERN_EFFECT_VOLUME, // F3
GUI_COLOR_PATTERN_EFFECT_VOLUME, // F4
GUI_COLOR_PATTERN_EFFECT_INVALID, // F5
GUI_COLOR_PATTERN_EFFECT_INVALID, // F6
GUI_COLOR_PATTERN_EFFECT_MISC, // F5
GUI_COLOR_PATTERN_EFFECT_MISC, // F6
GUI_COLOR_PATTERN_EFFECT_INVALID, // F7
GUI_COLOR_PATTERN_EFFECT_VOLUME, // F8
GUI_COLOR_PATTERN_EFFECT_VOLUME, // F9