1346 lines
47 KiB
C++
1346 lines
47 KiB
C++
// This is the Opal OPL3 emulator from Reality Adlib Tracker v2.0a (http://www.3eality.com/productions/reality-adlib-tracker).
|
|
// It was released by Shayde/Reality into the public domain.
|
|
// Minor modifications to silence some warnings and fix a bug in the envelope generator have been applied.
|
|
// Additional fixes by JP Cimalando.
|
|
|
|
/*
|
|
|
|
The Opal OPL3 emulator.
|
|
|
|
Note: this is not a complete emulator, just enough for Reality Adlib Tracker tunes.
|
|
|
|
Missing features compared to a real OPL3:
|
|
|
|
- Timers/interrupts
|
|
- OPL3 enable bit (it defaults to always on)
|
|
- CSW mode
|
|
- Test register
|
|
- Percussion mode
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <cstdint>
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Opal class.
|
|
//==================================================================================================
|
|
class Opal {
|
|
|
|
class Channel;
|
|
|
|
// Various constants
|
|
enum {
|
|
OPL3SampleRate = 49716,
|
|
NumChannels = 18,
|
|
NumOperators = 36,
|
|
|
|
EnvOff = -1,
|
|
EnvAtt,
|
|
EnvDec,
|
|
EnvSus,
|
|
EnvRel,
|
|
};
|
|
|
|
// A single FM operator
|
|
class Operator {
|
|
|
|
public:
|
|
Operator();
|
|
void SetMaster(Opal *opal) { Master = opal; }
|
|
void SetChannel(Channel *chan) { Chan = chan; }
|
|
|
|
int16_t Output(uint16_t keyscalenum, uint32_t phase_step, int16_t vibrato, int16_t mod = 0, int16_t fbshift = 0);
|
|
|
|
void SetKeyOn(bool on);
|
|
void SetTremoloEnable(bool on);
|
|
void SetVibratoEnable(bool on);
|
|
void SetSustainMode(bool on);
|
|
void SetEnvelopeScaling(bool on);
|
|
void SetFrequencyMultiplier(uint16_t scale);
|
|
void SetKeyScale(uint16_t scale);
|
|
void SetOutputLevel(uint16_t level);
|
|
void SetAttackRate(uint16_t rate);
|
|
void SetDecayRate(uint16_t rate);
|
|
void SetSustainLevel(uint16_t level);
|
|
void SetReleaseRate(uint16_t rate);
|
|
void SetWaveform(uint16_t wave);
|
|
|
|
void ComputeRates();
|
|
void ComputeKeyScaleLevel();
|
|
|
|
protected:
|
|
Opal * Master; // Master object
|
|
Channel * Chan; // Owning channel
|
|
uint32_t Phase; // The current offset in the selected waveform
|
|
uint16_t Waveform; // The waveform id this operator is using
|
|
uint16_t FreqMultTimes2; // Frequency multiplier * 2
|
|
int EnvelopeStage; // Which stage the envelope is at (see Env* enums above)
|
|
int16_t EnvelopeLevel; // 0 - $1FF, 0 being the loudest
|
|
uint16_t OutputLevel; // 0 - $FF
|
|
uint16_t AttackRate;
|
|
uint16_t DecayRate;
|
|
uint16_t SustainLevel;
|
|
uint16_t ReleaseRate;
|
|
uint16_t AttackShift;
|
|
uint16_t AttackMask;
|
|
uint16_t AttackAdd;
|
|
const uint16_t *AttackTab;
|
|
uint16_t DecayShift;
|
|
uint16_t DecayMask;
|
|
uint16_t DecayAdd;
|
|
const uint16_t *DecayTab;
|
|
uint16_t ReleaseShift;
|
|
uint16_t ReleaseMask;
|
|
uint16_t ReleaseAdd;
|
|
const uint16_t *ReleaseTab;
|
|
uint16_t KeyScaleShift;
|
|
uint16_t KeyScaleLevel;
|
|
int16_t Out[2];
|
|
bool KeyOn;
|
|
bool KeyScaleRate; // Affects envelope rate scaling
|
|
bool SustainMode; // Whether to sustain during the sustain phase, or release instead
|
|
bool TremoloEnable;
|
|
bool VibratoEnable;
|
|
};
|
|
|
|
// A single channel, which can contain two or more operators
|
|
class Channel {
|
|
|
|
public:
|
|
Channel();
|
|
void SetMaster(Opal *opal) { Master = opal; }
|
|
void SetOperators(Operator *a, Operator *b, Operator *c, Operator *d) {
|
|
Op[0] = a;
|
|
Op[1] = b;
|
|
Op[2] = c;
|
|
Op[3] = d;
|
|
if (a)
|
|
a->SetChannel(this);
|
|
if (b)
|
|
b->SetChannel(this);
|
|
if (c)
|
|
c->SetChannel(this);
|
|
if (d)
|
|
d->SetChannel(this);
|
|
}
|
|
|
|
void Output(int16_t &left, int16_t &right);
|
|
void SetEnable(bool on) { Enable = on; }
|
|
void SetChannelPair(Channel *pair) { ChannelPair = pair; }
|
|
|
|
void SetFrequencyLow(uint16_t freq);
|
|
void SetFrequencyHigh(uint16_t freq);
|
|
void SetKeyOn(bool on);
|
|
void SetOctave(uint16_t oct);
|
|
void SetLeftEnable(bool on);
|
|
void SetRightEnable(bool on);
|
|
void SetFeedback(uint16_t val);
|
|
void SetModulationType(uint16_t type);
|
|
|
|
uint16_t GetFreq() const { return Freq; }
|
|
uint16_t GetOctave() const { return Octave; }
|
|
uint16_t GetKeyScaleNumber() const { return KeyScaleNumber; }
|
|
uint16_t GetModulationType() const { return ModulationType; }
|
|
Channel * GetChannelPair() const { return ChannelPair; }
|
|
|
|
void ComputeKeyScaleNumber();
|
|
|
|
protected:
|
|
void ComputePhaseStep();
|
|
|
|
Operator * Op[4];
|
|
|
|
Opal * Master; // Master object
|
|
uint16_t Freq; // Frequency; actually it's a phase stepping value
|
|
uint16_t Octave; // Also known as "block" in Yamaha parlance
|
|
uint32_t PhaseStep;
|
|
uint16_t KeyScaleNumber;
|
|
uint16_t FeedbackShift;
|
|
uint16_t ModulationType;
|
|
Channel * ChannelPair;
|
|
bool Enable;
|
|
bool LeftEnable, RightEnable;
|
|
};
|
|
|
|
public:
|
|
Opal(int sample_rate);
|
|
Opal(const Opal &) = delete;
|
|
Opal(Opal &&) = delete;
|
|
~Opal();
|
|
|
|
void SetSampleRate(int sample_rate);
|
|
void Port(uint16_t reg_num, uint8_t val);
|
|
void Sample(int16_t *left, int16_t *right);
|
|
|
|
protected:
|
|
void Init(int sample_rate);
|
|
void Output(int16_t &left, int16_t &right);
|
|
|
|
int32_t SampleRate;
|
|
int32_t SampleAccum;
|
|
int16_t LastOutput[2], CurrOutput[2];
|
|
Channel Chan[NumChannels];
|
|
Operator Op[NumOperators];
|
|
// uint16_t ExpTable[256];
|
|
// uint16_t LogSinTable[256];
|
|
uint16_t Clock;
|
|
uint16_t TremoloClock;
|
|
uint16_t TremoloLevel;
|
|
uint16_t VibratoTick;
|
|
uint16_t VibratoClock;
|
|
bool NoteSel;
|
|
bool TremoloDepth;
|
|
bool VibratoDepth;
|
|
|
|
static const uint16_t RateTables[4][8];
|
|
static const uint16_t ExpTable[256];
|
|
static const uint16_t LogSinTable[256];
|
|
};
|
|
//--------------------------------------------------------------------------------------------------
|
|
const uint16_t Opal::RateTables[4][8] = {
|
|
{ 1, 0, 1, 0, 1, 0, 1, 0 },
|
|
{ 1, 0, 1, 0, 0, 0, 1, 0 },
|
|
{ 1, 0, 0, 0, 1, 0, 0, 0 },
|
|
{ 1, 0, 0, 0, 0, 0, 0, 0 },
|
|
};
|
|
//--------------------------------------------------------------------------------------------------
|
|
const uint16_t Opal::ExpTable[0x100] = {
|
|
1018, 1013, 1007, 1002, 996, 991, 986, 980, 975, 969, 964, 959, 953, 948, 942, 937,
|
|
932, 927, 921, 916, 911, 906, 900, 895, 890, 885, 880, 874, 869, 864, 859, 854,
|
|
849, 844, 839, 834, 829, 824, 819, 814, 809, 804, 799, 794, 789, 784, 779, 774,
|
|
770, 765, 760, 755, 750, 745, 741, 736, 731, 726, 722, 717, 712, 708, 703, 698,
|
|
693, 689, 684, 680, 675, 670, 666, 661, 657, 652, 648, 643, 639, 634, 630, 625,
|
|
621, 616, 612, 607, 603, 599, 594, 590, 585, 581, 577, 572, 568, 564, 560, 555,
|
|
551, 547, 542, 538, 534, 530, 526, 521, 517, 513, 509, 505, 501, 496, 492, 488,
|
|
484, 480, 476, 472, 468, 464, 460, 456, 452, 448, 444, 440, 436, 432, 428, 424,
|
|
420, 416, 412, 409, 405, 401, 397, 393, 389, 385, 382, 378, 374, 370, 367, 363,
|
|
359, 355, 352, 348, 344, 340, 337, 333, 329, 326, 322, 318, 315, 311, 308, 304,
|
|
300, 297, 293, 290, 286, 283, 279, 276, 272, 268, 265, 262, 258, 255, 251, 248,
|
|
244, 241, 237, 234, 231, 227, 224, 220, 217, 214, 210, 207, 204, 200, 197, 194,
|
|
190, 187, 184, 181, 177, 174, 171, 168, 164, 161, 158, 155, 152, 148, 145, 142,
|
|
139, 136, 133, 130, 126, 123, 120, 117, 114, 111, 108, 105, 102, 99, 96, 93,
|
|
90, 87, 84, 81, 78, 75, 72, 69, 66, 63, 60, 57, 54, 51, 48, 45,
|
|
42, 40, 37, 34, 31, 28, 25, 22, 20, 17, 14, 11, 8, 6, 3, 0,
|
|
};
|
|
//--------------------------------------------------------------------------------------------------
|
|
const uint16_t Opal::LogSinTable[0x100] = {
|
|
2137, 1731, 1543, 1419, 1326, 1252, 1190, 1137, 1091, 1050, 1013, 979, 949, 920, 894, 869,
|
|
846, 825, 804, 785, 767, 749, 732, 717, 701, 687, 672, 659, 646, 633, 621, 609,
|
|
598, 587, 576, 566, 556, 546, 536, 527, 518, 509, 501, 492, 484, 476, 468, 461,
|
|
453, 446, 439, 432, 425, 418, 411, 405, 399, 392, 386, 380, 375, 369, 363, 358,
|
|
352, 347, 341, 336, 331, 326, 321, 316, 311, 307, 302, 297, 293, 289, 284, 280,
|
|
276, 271, 267, 263, 259, 255, 251, 248, 244, 240, 236, 233, 229, 226, 222, 219,
|
|
215, 212, 209, 205, 202, 199, 196, 193, 190, 187, 184, 181, 178, 175, 172, 169,
|
|
167, 164, 161, 159, 156, 153, 151, 148, 146, 143, 141, 138, 136, 134, 131, 129,
|
|
127, 125, 122, 120, 118, 116, 114, 112, 110, 108, 106, 104, 102, 100, 98, 96,
|
|
94, 92, 91, 89, 87, 85, 83, 82, 80, 78, 77, 75, 74, 72, 70, 69,
|
|
67, 66, 64, 63, 62, 60, 59, 57, 56, 55, 53, 52, 51, 49, 48, 47,
|
|
46, 45, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30,
|
|
29, 28, 27, 26, 25, 24, 23, 23, 22, 21, 20, 20, 19, 18, 17, 17,
|
|
16, 15, 15, 14, 13, 13, 12, 12, 11, 10, 10, 9, 9, 8, 8, 7,
|
|
7, 7, 6, 6, 5, 5, 5, 4, 4, 4, 3, 3, 3, 2, 2, 2,
|
|
2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
};
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// This is the temporary code for generating the above tables. Maths and data from this nice
|
|
// reverse-engineering effort:
|
|
//
|
|
// https://docs.google.com/document/d/18IGx18NQY_Q1PJVZ-bHywao9bhsDoAqoIn1rIm42nwo/edit
|
|
//==================================================================================================
|
|
#if 0
|
|
#include <math.h>
|
|
|
|
void GenerateTables() {
|
|
|
|
// Build the exponentiation table (reversed from the official OPL3 ROM)
|
|
FILE *fd = fopen("exptab.txt", "wb");
|
|
if (fd) {
|
|
for (int i = 0; i < 0x100; i++) {
|
|
int v = (pow(2, (0xFF - i) / 256.0) - 1) * 1024 + 0.5;
|
|
if (i & 15)
|
|
fprintf(fd, " %4d,", v);
|
|
else
|
|
fprintf(fd, "\n\t%4d,", v);
|
|
}
|
|
fclose(fd);
|
|
}
|
|
|
|
// Build the log-sin table
|
|
fd = fopen("sintab.txt", "wb");
|
|
if (fd) {
|
|
for (int i = 0; i < 0x100; i++) {
|
|
int v = -log(sin((i + 0.5) * 3.1415926535897933 / 256 / 2)) / log(2) * 256 + 0.5;
|
|
if (i & 15)
|
|
fprintf(fd, " %4d,", v);
|
|
else
|
|
fprintf(fd, "\n\t%4d,", v);
|
|
}
|
|
fclose(fd);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Constructor/destructor.
|
|
//==================================================================================================
|
|
Opal::Opal(int sample_rate) {
|
|
|
|
Init(sample_rate);
|
|
}
|
|
//--------------------------------------------------------------------------------------------------
|
|
Opal::~Opal() {
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Initialise the emulation.
|
|
//==================================================================================================
|
|
void Opal::Init(int sample_rate) {
|
|
|
|
Clock = 0;
|
|
TremoloClock = 0;
|
|
TremoloLevel = 0;
|
|
VibratoTick = 0;
|
|
VibratoClock = 0;
|
|
NoteSel = false;
|
|
TremoloDepth = false;
|
|
VibratoDepth = false;
|
|
|
|
// // Build the exponentiation table (reversed from the official OPL3 ROM)
|
|
// for (int i = 0; i < 0x100; i++)
|
|
// ExpTable[i] = (pow(2, (0xFF - i) / 256.0) - 1) * 1024 + 0.5;
|
|
//
|
|
// // Build the log-sin table
|
|
// for (int i = 0; i < 0x100; i++)
|
|
// LogSinTable[i] = -log(sin((i + 0.5) * 3.1415926535897933 / 256 / 2)) / log(2) * 256 + 0.5;
|
|
|
|
// Let sub-objects know where to find us
|
|
for (int i = 0; i < NumOperators; i++)
|
|
Op[i].SetMaster(this);
|
|
|
|
for (int i = 0; i < NumChannels; i++)
|
|
Chan[i].SetMaster(this);
|
|
|
|
// Add the operators to the channels. Note, some channels can't use all the operators
|
|
// FIXME: put this into a separate routine
|
|
const int chan_ops[] = {
|
|
0, 1, 2, 6, 7, 8, 12, 13, 14, 18, 19, 20, 24, 25, 26, 30, 31, 32,
|
|
};
|
|
|
|
for (int i = 0; i < NumChannels; i++) {
|
|
Channel *chan = &Chan[i];
|
|
int op = chan_ops[i];
|
|
if (i < 3 || (i >= 9 && i < 12))
|
|
chan->SetOperators(&Op[op], &Op[op + 3], &Op[op + 6], &Op[op + 9]);
|
|
else
|
|
chan->SetOperators(&Op[op], &Op[op + 3], 0, 0);
|
|
}
|
|
|
|
// Initialise the operator rate data. We can't do this in the Operator constructor as it
|
|
// relies on referencing the master and channel objects
|
|
for (int i = 0; i < NumOperators; i++)
|
|
Op[i].ComputeRates();
|
|
|
|
SetSampleRate(sample_rate);
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Change the sample rate.
|
|
//==================================================================================================
|
|
void Opal::SetSampleRate(int sample_rate) {
|
|
|
|
// Sanity
|
|
if (sample_rate == 0)
|
|
sample_rate = OPL3SampleRate;
|
|
|
|
SampleRate = sample_rate;
|
|
SampleAccum = 0;
|
|
LastOutput[0] = LastOutput[1] = 0;
|
|
CurrOutput[0] = CurrOutput[1] = 0;
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Write a value to an OPL3 register.
|
|
//==================================================================================================
|
|
void Opal::Port(uint16_t reg_num, uint8_t val) {
|
|
|
|
static constexpr int8_t op_lookup[] = {
|
|
// 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
|
|
0, 1, 2, 3, 4, 5, -1, -1, 6, 7, 8, 9, 10, 11, -1, -1,
|
|
// 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F
|
|
12, 13, 14, 15, 16, 17, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
};
|
|
|
|
uint16_t type = reg_num & 0xE0;
|
|
|
|
// Is it BD, the one-off register stuck in the middle of the register array?
|
|
if (reg_num == 0xBD) {
|
|
TremoloDepth = (val & 0x80) != 0;
|
|
VibratoDepth = (val & 0x40) != 0;
|
|
return;
|
|
}
|
|
|
|
// Global registers
|
|
if (type == 0x00) {
|
|
|
|
// 4-OP enables
|
|
if (reg_num == 0x104) {
|
|
|
|
// Enable/disable channels based on which 4-op enables
|
|
uint8_t mask = 1;
|
|
for (int i = 0; i < 6; i++, mask <<= 1) {
|
|
|
|
// The 4-op channels are 0, 1, 2, 9, 10, 11
|
|
uint16_t chan = static_cast<uint16_t>(i < 3 ? i : i + 6);
|
|
Channel *primary = &Chan[chan];
|
|
Channel *secondary = &Chan[chan + 3];
|
|
|
|
if (val & mask) {
|
|
|
|
// Let primary channel know it's controlling the secondary channel
|
|
primary->SetChannelPair(secondary);
|
|
|
|
// Turn off the second channel in the pair
|
|
secondary->SetEnable(false);
|
|
|
|
} else {
|
|
|
|
// Let primary channel know it's no longer controlling the secondary channel
|
|
primary->SetChannelPair(0);
|
|
|
|
// Turn on the second channel in the pair
|
|
secondary->SetEnable(true);
|
|
}
|
|
}
|
|
|
|
// CSW / Note-sel
|
|
} else if (reg_num == 0x08) {
|
|
|
|
NoteSel = (val & 0x40) != 0;
|
|
|
|
// Get the channels to recompute the Key Scale No. as this varies based on NoteSel
|
|
for (int i = 0; i < NumChannels; i++)
|
|
Chan[i].ComputeKeyScaleNumber();
|
|
}
|
|
|
|
// Channel registers
|
|
} else if (type >= 0xA0 && type <= 0xC0) {
|
|
|
|
// Convert to channel number
|
|
int chan_num = reg_num & 15;
|
|
|
|
// Valid channel?
|
|
if (chan_num >= 9)
|
|
return;
|
|
|
|
// Is it the other bank of channels?
|
|
if (reg_num & 0x100)
|
|
chan_num += 9;
|
|
|
|
Channel &chan = Chan[chan_num];
|
|
|
|
// Registers Ax and Bx affect both channels
|
|
Channel *chans[2] = {&chan, chan.GetChannelPair()};
|
|
int numchans = chans[1] ? 2 : 1;
|
|
|
|
// Do specific registers
|
|
switch (reg_num & 0xF0) {
|
|
|
|
// Frequency low
|
|
case 0xA0: {
|
|
for (int i = 0; i < numchans; i++) {
|
|
chans[i]->SetFrequencyLow(val);
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Key-on / Octave / Frequency High
|
|
case 0xB0: {
|
|
for (int i = 0; i < numchans; i++) {
|
|
chans[i]->SetKeyOn((val & 0x20) != 0);
|
|
chans[i]->SetOctave(val >> 2 & 7);
|
|
chans[i]->SetFrequencyHigh(val & 3);
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Right Stereo Channel Enable / Left Stereo Channel Enable / Feedback Factor / Modulation Type
|
|
case 0xC0: {
|
|
chan.SetRightEnable((val & 0x20) != 0);
|
|
chan.SetLeftEnable((val & 0x10) != 0);
|
|
chan.SetFeedback(val >> 1 & 7);
|
|
chan.SetModulationType(val & 1);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Operator registers
|
|
} else if ((type >= 0x20 && type <= 0x80) || type == 0xE0) {
|
|
|
|
// Convert to operator number
|
|
int op_num = op_lookup[reg_num & 0x1F];
|
|
|
|
// Valid register?
|
|
if (op_num < 0)
|
|
return;
|
|
|
|
// Is it the other bank of operators?
|
|
if (reg_num & 0x100)
|
|
op_num += 18;
|
|
|
|
Operator &op = Op[op_num];
|
|
|
|
// Do specific registers
|
|
switch (type) {
|
|
|
|
// Tremolo Enable / Vibrato Enable / Sustain Mode / Envelope Scaling / Frequency Multiplier
|
|
case 0x20: {
|
|
op.SetTremoloEnable((val & 0x80) != 0);
|
|
op.SetVibratoEnable((val & 0x40) != 0);
|
|
op.SetSustainMode((val & 0x20) != 0);
|
|
op.SetEnvelopeScaling((val & 0x10) != 0);
|
|
op.SetFrequencyMultiplier(val & 15);
|
|
break;
|
|
}
|
|
|
|
// Key Scale / Output Level
|
|
case 0x40: {
|
|
op.SetKeyScale(val >> 6);
|
|
op.SetOutputLevel(val & 0x3F);
|
|
break;
|
|
}
|
|
|
|
// Attack Rate / Decay Rate
|
|
case 0x60: {
|
|
op.SetAttackRate(val >> 4);
|
|
op.SetDecayRate(val & 15);
|
|
break;
|
|
}
|
|
|
|
// Sustain Level / Release Rate
|
|
case 0x80: {
|
|
op.SetSustainLevel(val >> 4);
|
|
op.SetReleaseRate(val & 15);
|
|
break;
|
|
}
|
|
|
|
// Waveform
|
|
case 0xE0: {
|
|
op.SetWaveform(val & 7);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Generate sample. Every time you call this you will get two signed 16-bit samples (one for each
|
|
// stereo channel) which will sound correct when played back at the sample rate given when the
|
|
// class was constructed.
|
|
//==================================================================================================
|
|
void Opal::Sample(int16_t *left, int16_t *right) {
|
|
|
|
// If the destination sample rate is higher than the OPL3 sample rate, we need to skip ahead
|
|
while (SampleAccum >= SampleRate) {
|
|
|
|
LastOutput[0] = CurrOutput[0];
|
|
LastOutput[1] = CurrOutput[1];
|
|
|
|
Output(CurrOutput[0], CurrOutput[1]);
|
|
|
|
SampleAccum -= SampleRate;
|
|
}
|
|
|
|
// Mix with the partial accumulation
|
|
int32_t omblend = SampleRate - SampleAccum;
|
|
*left = static_cast<uint16_t>((LastOutput[0] * omblend + CurrOutput[0] * SampleAccum) / SampleRate);
|
|
*right = static_cast<uint16_t>((LastOutput[1] * omblend + CurrOutput[1] * SampleAccum) / SampleRate);
|
|
|
|
SampleAccum += OPL3SampleRate;
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Produce final output from the chip. This is at the OPL3 sample-rate.
|
|
//==================================================================================================
|
|
void Opal::Output(int16_t &left, int16_t &right) {
|
|
|
|
int32_t leftmix = 0, rightmix = 0;
|
|
|
|
// Sum the output of each channel
|
|
for (int i = 0; i < NumChannels; i++) {
|
|
|
|
int16_t chanleft, chanright;
|
|
Chan[i].Output(chanleft, chanright);
|
|
|
|
leftmix += chanleft;
|
|
rightmix += chanright;
|
|
}
|
|
|
|
// Clamp
|
|
if (leftmix < -0x8000)
|
|
left = -0x8000;
|
|
else if (leftmix > 0x7FFF)
|
|
left = 0x7FFF;
|
|
else
|
|
left = static_cast<uint16_t>(leftmix);
|
|
|
|
if (rightmix < -0x8000)
|
|
right = -0x8000;
|
|
else if (rightmix > 0x7FFF)
|
|
right = 0x7FFF;
|
|
else
|
|
right = static_cast<uint16_t>(rightmix);
|
|
|
|
Clock++;
|
|
|
|
// Tremolo. According to this post, the OPL3 tremolo is a 13,440 sample length triangle wave
|
|
// with a peak at 26 and a trough at 0 and is simply added to the logarithmic level accumulator
|
|
// http://forums.submarine.org.uk/phpBB/viewtopic.php?f=9&t=1171
|
|
TremoloClock = (TremoloClock + 1) % 13440;
|
|
TremoloLevel = ((TremoloClock < 13440 / 2) ? TremoloClock : 13440 - TremoloClock) / 256;
|
|
if (!TremoloDepth)
|
|
TremoloLevel >>= 2;
|
|
|
|
// Vibrato. This appears to be a 8 sample long triangle wave with a magnitude of the three
|
|
// high bits of the channel frequency, positive and negative, divided by two if the vibrato
|
|
// depth is zero. It is only cycled every 1,024 samples.
|
|
VibratoTick++;
|
|
if (VibratoTick >= 1024) {
|
|
VibratoTick = 0;
|
|
VibratoClock = (VibratoClock + 1) & 7;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Channel constructor.
|
|
//==================================================================================================
|
|
Opal::Channel::Channel() {
|
|
|
|
Master = 0;
|
|
Freq = 0;
|
|
Octave = 0;
|
|
PhaseStep = 0;
|
|
KeyScaleNumber = 0;
|
|
FeedbackShift = 0;
|
|
ModulationType = 0;
|
|
ChannelPair = 0;
|
|
Enable = true;
|
|
LeftEnable = true;
|
|
RightEnable = true;
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Produce output from channel.
|
|
//==================================================================================================
|
|
void Opal::Channel::Output(int16_t &left, int16_t &right) {
|
|
|
|
// Has the channel been disabled? This is usually a result of the 4-op enables being used to
|
|
// disable the secondary channel in each 4-op pair
|
|
if (!Enable) {
|
|
left = right = 0;
|
|
return;
|
|
}
|
|
|
|
int16_t vibrato = (Freq >> 7) & 7;
|
|
if (!Master->VibratoDepth)
|
|
vibrato >>= 1;
|
|
|
|
// 0 3 7 3 0 -3 -7 -3
|
|
uint16_t clk = Master->VibratoClock;
|
|
if (!(clk & 3))
|
|
vibrato = 0; // Position 0 and 4 is zero
|
|
else {
|
|
if (clk & 1)
|
|
vibrato >>= 1; // Odd positions are half the magnitude
|
|
|
|
vibrato <<= Octave;
|
|
|
|
if (clk & 4)
|
|
vibrato = -vibrato; // The second half positions are negative
|
|
}
|
|
|
|
// Combine individual operator outputs
|
|
int16_t out, acc;
|
|
|
|
// Running in 4-op mode?
|
|
if (ChannelPair) {
|
|
|
|
// Get the secondary channel's modulation type. This is the only thing from the secondary
|
|
// channel that is used
|
|
if (ChannelPair->GetModulationType() == 0) {
|
|
|
|
if (ModulationType == 0) {
|
|
|
|
// feedback -> modulator -> modulator -> modulator -> carrier
|
|
out = Op[0]->Output(KeyScaleNumber, PhaseStep, vibrato, 0, FeedbackShift);
|
|
out = Op[1]->Output(KeyScaleNumber, PhaseStep, vibrato, out, 0);
|
|
out = Op[2]->Output(KeyScaleNumber, PhaseStep, vibrato, out, 0);
|
|
out = Op[3]->Output(KeyScaleNumber, PhaseStep, vibrato, out, 0);
|
|
|
|
} else {
|
|
|
|
// (feedback -> carrier) + (modulator -> modulator -> carrier)
|
|
out = Op[0]->Output(KeyScaleNumber, PhaseStep, vibrato, 0, FeedbackShift);
|
|
acc = Op[1]->Output(KeyScaleNumber, PhaseStep, vibrato, 0, 0);
|
|
acc = Op[2]->Output(KeyScaleNumber, PhaseStep, vibrato, acc, 0);
|
|
out += Op[3]->Output(KeyScaleNumber, PhaseStep, vibrato, acc, 0);
|
|
}
|
|
|
|
} else {
|
|
|
|
if (ModulationType == 0) {
|
|
|
|
// (feedback -> modulator -> carrier) + (modulator -> carrier)
|
|
out = Op[0]->Output(KeyScaleNumber, PhaseStep, vibrato, 0, FeedbackShift);
|
|
out = Op[1]->Output(KeyScaleNumber, PhaseStep, vibrato, out, 0);
|
|
acc = Op[2]->Output(KeyScaleNumber, PhaseStep, vibrato, 0, 0);
|
|
out += Op[3]->Output(KeyScaleNumber, PhaseStep, vibrato, acc, 0);
|
|
|
|
} else {
|
|
|
|
// (feedback -> carrier) + (modulator -> carrier) + carrier
|
|
out = Op[0]->Output(KeyScaleNumber, PhaseStep, vibrato, 0, FeedbackShift);
|
|
acc = Op[1]->Output(KeyScaleNumber, PhaseStep, vibrato, 0, 0);
|
|
out += Op[2]->Output(KeyScaleNumber, PhaseStep, vibrato, acc, 0);
|
|
out += Op[3]->Output(KeyScaleNumber, PhaseStep, vibrato, 0, 0);
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
// Standard 2-op mode
|
|
if (ModulationType == 0) {
|
|
|
|
// Frequency modulation (well, phase modulation technically)
|
|
out = Op[0]->Output(KeyScaleNumber, PhaseStep, vibrato, 0, FeedbackShift);
|
|
out = Op[1]->Output(KeyScaleNumber, PhaseStep, vibrato, out, 0);
|
|
|
|
} else {
|
|
|
|
// Additive
|
|
out = Op[0]->Output(KeyScaleNumber, PhaseStep, vibrato, 0, FeedbackShift);
|
|
out += Op[1]->Output(KeyScaleNumber, PhaseStep, vibrato);
|
|
}
|
|
}
|
|
|
|
left = LeftEnable ? out : 0;
|
|
right = RightEnable ? out : 0;
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Set phase step for operators using this channel.
|
|
//==================================================================================================
|
|
void Opal::Channel::SetFrequencyLow(uint16_t freq) {
|
|
|
|
Freq = (Freq & 0x300) | (freq & 0xFF);
|
|
ComputePhaseStep();
|
|
}
|
|
//--------------------------------------------------------------------------------------------------
|
|
void Opal::Channel::SetFrequencyHigh(uint16_t freq) {
|
|
|
|
Freq = (Freq & 0xFF) | ((freq & 3) << 8);
|
|
ComputePhaseStep();
|
|
|
|
// Only the high bits of Freq affect the Key Scale No.
|
|
ComputeKeyScaleNumber();
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Set the octave of the channel (0 to 7).
|
|
//==================================================================================================
|
|
void Opal::Channel::SetOctave(uint16_t oct) {
|
|
|
|
Octave = oct & 7;
|
|
ComputePhaseStep();
|
|
ComputeKeyScaleNumber();
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Keys the channel on/off.
|
|
//==================================================================================================
|
|
void Opal::Channel::SetKeyOn(bool on) {
|
|
|
|
Op[0]->SetKeyOn(on);
|
|
Op[1]->SetKeyOn(on);
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Enable left stereo channel.
|
|
//==================================================================================================
|
|
void Opal::Channel::SetLeftEnable(bool on) {
|
|
|
|
LeftEnable = on;
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Enable right stereo channel.
|
|
//==================================================================================================
|
|
void Opal::Channel::SetRightEnable(bool on) {
|
|
|
|
RightEnable = on;
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Set the channel feedback amount.
|
|
//==================================================================================================
|
|
void Opal::Channel::SetFeedback(uint16_t val) {
|
|
|
|
FeedbackShift = val ? 9 - val : 0;
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Set frequency modulation/additive modulation
|
|
//==================================================================================================
|
|
void Opal::Channel::SetModulationType(uint16_t type) {
|
|
|
|
ModulationType = type;
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Compute the stepping factor for the operator waveform phase based on the frequency and octave
|
|
// values of the channel.
|
|
//==================================================================================================
|
|
void Opal::Channel::ComputePhaseStep() {
|
|
|
|
PhaseStep = uint32_t(Freq) << Octave;
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Compute the key scale number and key scale levels.
|
|
//
|
|
// From the Yamaha data sheet this is the block/octave number as bits 3-1, with bit 0 coming from
|
|
// the MSB of the frequency if NoteSel is 1, and the 2nd MSB if NoteSel is 0.
|
|
//==================================================================================================
|
|
void Opal::Channel::ComputeKeyScaleNumber() {
|
|
|
|
uint16_t lsb = Master->NoteSel ? Freq >> 9 : (Freq >> 8) & 1;
|
|
KeyScaleNumber = Octave << 1 | lsb;
|
|
|
|
// Get the channel operators to recompute their rates as they're dependent on this number. They
|
|
// also need to recompute their key scale level
|
|
for (int i = 0; i < 4; i++) {
|
|
|
|
if (!Op[i])
|
|
continue;
|
|
|
|
Op[i]->ComputeRates();
|
|
Op[i]->ComputeKeyScaleLevel();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Operator constructor.
|
|
//==================================================================================================
|
|
Opal::Operator::Operator() {
|
|
|
|
Master = 0;
|
|
Chan = 0;
|
|
Phase = 0;
|
|
Waveform = 0;
|
|
FreqMultTimes2 = 1;
|
|
EnvelopeStage = EnvOff;
|
|
EnvelopeLevel = 0x1FF;
|
|
AttackRate = 0;
|
|
DecayRate = 0;
|
|
SustainLevel = 0;
|
|
ReleaseRate = 0;
|
|
KeyScaleShift = 0;
|
|
KeyScaleLevel = 0;
|
|
Out[0] = Out[1] = 0;
|
|
KeyOn = false;
|
|
KeyScaleRate = false;
|
|
SustainMode = false;
|
|
TremoloEnable = false;
|
|
VibratoEnable = false;
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Produce output from operator.
|
|
//==================================================================================================
|
|
int16_t Opal::Operator::Output(uint16_t /*keyscalenum*/, uint32_t phase_step, int16_t vibrato, int16_t mod, int16_t fbshift) {
|
|
|
|
// Advance wave phase
|
|
if (VibratoEnable)
|
|
phase_step += vibrato;
|
|
Phase += (phase_step * FreqMultTimes2) / 2;
|
|
|
|
uint16_t level = (EnvelopeLevel + OutputLevel + KeyScaleLevel + (TremoloEnable ? Master->TremoloLevel : 0)) << 3;
|
|
|
|
switch (EnvelopeStage) {
|
|
|
|
// Attack stage
|
|
case EnvAtt: {
|
|
uint16_t add = ((AttackAdd >> AttackTab[Master->Clock >> AttackShift & 7]) * ~EnvelopeLevel) >> 3;
|
|
if (AttackRate == 0)
|
|
add = 0;
|
|
if (AttackMask && (Master->Clock & AttackMask))
|
|
add = 0;
|
|
EnvelopeLevel += add;
|
|
if (EnvelopeLevel <= 0) {
|
|
EnvelopeLevel = 0;
|
|
EnvelopeStage = EnvDec;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Decay stage
|
|
case EnvDec: {
|
|
uint16_t add = DecayAdd >> DecayTab[Master->Clock >> DecayShift & 7];
|
|
if (DecayRate == 0)
|
|
add = 0;
|
|
if (DecayMask && (Master->Clock & DecayMask))
|
|
add = 0;
|
|
EnvelopeLevel += add;
|
|
if (EnvelopeLevel >= SustainLevel) {
|
|
EnvelopeLevel = SustainLevel;
|
|
EnvelopeStage = EnvSus;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Sustain stage
|
|
case EnvSus: {
|
|
|
|
if (SustainMode)
|
|
break;
|
|
|
|
// Note: fall-through!
|
|
[[fallthrough]];
|
|
}
|
|
|
|
// Release stage
|
|
case EnvRel: {
|
|
uint16_t add = ReleaseAdd >> ReleaseTab[Master->Clock >> ReleaseShift & 7];
|
|
if (ReleaseRate == 0)
|
|
add = 0;
|
|
if (ReleaseMask && (Master->Clock & ReleaseMask))
|
|
add = 0;
|
|
EnvelopeLevel += add;
|
|
if (EnvelopeLevel >= 0x1FF) {
|
|
EnvelopeLevel = 0x1FF;
|
|
EnvelopeStage = EnvOff;
|
|
Out[0] = Out[1] = 0;
|
|
return 0;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Envelope, and therefore the operator, is not running
|
|
default:
|
|
Out[0] = Out[1] = 0;
|
|
return 0;
|
|
}
|
|
|
|
// Feedback? In that case we modulate by a blend of the last two samples
|
|
if (fbshift)
|
|
mod += (Out[0] + Out[1]) >> fbshift;
|
|
|
|
uint16_t phase = static_cast<uint16_t>(Phase >> 10) + mod;
|
|
uint16_t offset = phase & 0xFF;
|
|
uint16_t logsin;
|
|
bool negate = false;
|
|
|
|
switch (Waveform) {
|
|
|
|
//------------------------------------
|
|
// Standard sine wave
|
|
//------------------------------------
|
|
case 0:
|
|
if (phase & 0x100)
|
|
offset ^= 0xFF;
|
|
logsin = Master->LogSinTable[offset];
|
|
negate = (phase & 0x200) != 0;
|
|
break;
|
|
|
|
//------------------------------------
|
|
// Half sine wave
|
|
//------------------------------------
|
|
case 1:
|
|
if (phase & 0x200)
|
|
offset = 0;
|
|
else if (phase & 0x100)
|
|
offset ^= 0xFF;
|
|
logsin = Master->LogSinTable[offset];
|
|
break;
|
|
|
|
//------------------------------------
|
|
// Positive sine wave
|
|
//------------------------------------
|
|
case 2:
|
|
if (phase & 0x100)
|
|
offset ^= 0xFF;
|
|
logsin = Master->LogSinTable[offset];
|
|
break;
|
|
|
|
//------------------------------------
|
|
// Quarter positive sine wave
|
|
//------------------------------------
|
|
case 3:
|
|
if (phase & 0x100)
|
|
offset = 0;
|
|
logsin = Master->LogSinTable[offset];
|
|
break;
|
|
|
|
//------------------------------------
|
|
// Double-speed sine wave
|
|
//------------------------------------
|
|
case 4:
|
|
if (phase & 0x200)
|
|
offset = 0;
|
|
|
|
else {
|
|
|
|
if (phase & 0x80)
|
|
offset ^= 0xFF;
|
|
|
|
offset = (offset + offset) & 0xFF;
|
|
negate = (phase & 0x100) != 0;
|
|
}
|
|
|
|
logsin = Master->LogSinTable[offset];
|
|
break;
|
|
|
|
//------------------------------------
|
|
// Double-speed positive sine wave
|
|
//------------------------------------
|
|
case 5:
|
|
if (phase & 0x200)
|
|
offset = 0;
|
|
|
|
else {
|
|
|
|
offset = (offset + offset) & 0xFF;
|
|
if (phase & 0x80)
|
|
offset ^= 0xFF;
|
|
}
|
|
|
|
logsin = Master->LogSinTable[offset];
|
|
break;
|
|
|
|
//------------------------------------
|
|
// Square wave
|
|
//------------------------------------
|
|
case 6:
|
|
logsin = 0;
|
|
negate = (phase & 0x200) != 0;
|
|
break;
|
|
|
|
//------------------------------------
|
|
// Exponentiation wave
|
|
//------------------------------------
|
|
default:
|
|
logsin = phase & 0x1FF;
|
|
if (phase & 0x200) {
|
|
logsin ^= 0x1FF;
|
|
negate = true;
|
|
}
|
|
logsin <<= 3;
|
|
break;
|
|
}
|
|
|
|
uint16_t mix = logsin + level;
|
|
if (mix > 0x1FFF)
|
|
mix = 0x1FFF;
|
|
|
|
// From the OPLx decapsulated docs:
|
|
// "When such a table is used for calculation of the exponential, the table is read at the
|
|
// position given by the 8 LSB's of the input. The value + 1024 (the hidden bit) is then the
|
|
// significand of the floating point output and the yet unused MSB's of the input are the
|
|
// exponent of the floating point output."
|
|
int16_t v = (Master->ExpTable[mix & 0xFF] + 1024u) >> (mix >> 8u);
|
|
v += v;
|
|
if (negate)
|
|
v = ~v;
|
|
|
|
// Keep last two results for feedback calculation
|
|
Out[1] = Out[0];
|
|
Out[0] = v;
|
|
|
|
return v;
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Trigger operator.
|
|
//==================================================================================================
|
|
void Opal::Operator::SetKeyOn(bool on) {
|
|
|
|
// Already on/off?
|
|
if (KeyOn == on)
|
|
return;
|
|
KeyOn = on;
|
|
|
|
if (on) {
|
|
|
|
// The highest attack rate is instant; it bypasses the attack phase
|
|
if (AttackRate == 15) {
|
|
EnvelopeStage = EnvDec;
|
|
EnvelopeLevel = 0;
|
|
} else
|
|
EnvelopeStage = EnvAtt;
|
|
|
|
Phase = 0;
|
|
|
|
} else {
|
|
|
|
// Stopping current sound?
|
|
if (EnvelopeStage != EnvOff && EnvelopeStage != EnvRel)
|
|
EnvelopeStage = EnvRel;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Enable amplitude vibrato.
|
|
//==================================================================================================
|
|
void Opal::Operator::SetTremoloEnable(bool on) {
|
|
|
|
TremoloEnable = on;
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Enable frequency vibrato.
|
|
//==================================================================================================
|
|
void Opal::Operator::SetVibratoEnable(bool on) {
|
|
|
|
VibratoEnable = on;
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Sets whether we release or sustain during the sustain phase of the envelope. 'true' is to
|
|
// sustain, otherwise release.
|
|
//==================================================================================================
|
|
void Opal::Operator::SetSustainMode(bool on) {
|
|
|
|
SustainMode = on;
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Key scale rate. Sets how much the Key Scaling Number affects the envelope rates.
|
|
//==================================================================================================
|
|
void Opal::Operator::SetEnvelopeScaling(bool on) {
|
|
|
|
KeyScaleRate = on;
|
|
ComputeRates();
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Multiplies the phase frequency.
|
|
//==================================================================================================
|
|
void Opal::Operator::SetFrequencyMultiplier(uint16_t scale) {
|
|
|
|
// Needs to be multiplied by two (and divided by two later when we use it) because the first
|
|
// entry is actually .5
|
|
const uint16_t mul_times_2[] = {
|
|
1, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 20, 24, 24, 30, 30,
|
|
};
|
|
|
|
FreqMultTimes2 = mul_times_2[scale & 15];
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Attenuates output level towards higher pitch.
|
|
//==================================================================================================
|
|
void Opal::Operator::SetKeyScale(uint16_t scale) {
|
|
|
|
static constexpr uint8_t kslShift[4] = { 8, 1, 2, 0 };
|
|
KeyScaleShift = kslShift[scale];
|
|
ComputeKeyScaleLevel();
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Sets the output level (volume) of the operator.
|
|
//==================================================================================================
|
|
void Opal::Operator::SetOutputLevel(uint16_t level) {
|
|
|
|
OutputLevel = level * 4;
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Operator attack rate.
|
|
//==================================================================================================
|
|
void Opal::Operator::SetAttackRate(uint16_t rate) {
|
|
|
|
AttackRate = rate;
|
|
|
|
ComputeRates();
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Operator decay rate.
|
|
//==================================================================================================
|
|
void Opal::Operator::SetDecayRate(uint16_t rate) {
|
|
|
|
DecayRate = rate;
|
|
|
|
ComputeRates();
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Operator sustain level.
|
|
//==================================================================================================
|
|
void Opal::Operator::SetSustainLevel(uint16_t level) {
|
|
|
|
SustainLevel = level < 15 ? level : 31;
|
|
SustainLevel *= 16;
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Operator release rate.
|
|
//==================================================================================================
|
|
void Opal::Operator::SetReleaseRate(uint16_t rate) {
|
|
|
|
ReleaseRate = rate;
|
|
|
|
ComputeRates();
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Assign the waveform this operator will use.
|
|
//==================================================================================================
|
|
void Opal::Operator::SetWaveform(uint16_t wave) {
|
|
|
|
Waveform = wave & 7;
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Compute actual rate from register rate. From the Yamaha data sheet:
|
|
//
|
|
// Actual rate = Rate value * 4 + Rof, if Rate value = 0, actual rate = 0
|
|
//
|
|
// Rof is set as follows depending on the KSR setting:
|
|
//
|
|
// Key scale 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
|
|
// KSR = 0 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3
|
|
// KSR = 1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
|
|
//
|
|
// Note: zero rates are infinite, and are treated separately elsewhere
|
|
//==================================================================================================
|
|
void Opal::Operator::ComputeRates() {
|
|
|
|
int combined_rate = AttackRate * 4 + (Chan->GetKeyScaleNumber() >> (KeyScaleRate ? 0 : 2));
|
|
int rate_high = combined_rate >> 2;
|
|
int rate_low = combined_rate & 3;
|
|
|
|
AttackShift = static_cast<uint16_t>(rate_high < 12 ? 12 - rate_high : 0);
|
|
AttackMask = (1 << AttackShift) - 1;
|
|
AttackAdd = (rate_high < 12) ? 1 : 1 << (rate_high - 12);
|
|
AttackTab = Master->RateTables[rate_low];
|
|
|
|
// Attack rate of 15 is always instant
|
|
if (AttackRate == 15)
|
|
AttackAdd = 0xFFF;
|
|
|
|
combined_rate = DecayRate * 4 + (Chan->GetKeyScaleNumber() >> (KeyScaleRate ? 0 : 2));
|
|
rate_high = combined_rate >> 2;
|
|
rate_low = combined_rate & 3;
|
|
|
|
DecayShift = static_cast<uint16_t>(rate_high < 12 ? 12 - rate_high : 0);
|
|
DecayMask = (1 << DecayShift) - 1;
|
|
DecayAdd = (rate_high < 12) ? 1 : 1 << (rate_high - 12);
|
|
DecayTab = Master->RateTables[rate_low];
|
|
|
|
combined_rate = ReleaseRate * 4 + (Chan->GetKeyScaleNumber() >> (KeyScaleRate ? 0 : 2));
|
|
rate_high = combined_rate >> 2;
|
|
rate_low = combined_rate & 3;
|
|
|
|
ReleaseShift = static_cast<uint16_t>(rate_high < 12 ? 12 - rate_high : 0);
|
|
ReleaseMask = (1 << ReleaseShift) - 1;
|
|
ReleaseAdd = (rate_high < 12) ? 1 : 1 << (rate_high - 12);
|
|
ReleaseTab = Master->RateTables[rate_low];
|
|
}
|
|
|
|
|
|
|
|
//==================================================================================================
|
|
// Compute the operator's key scale level. This changes based on the channel frequency/octave and
|
|
// operator key scale value.
|
|
//==================================================================================================
|
|
void Opal::Operator::ComputeKeyScaleLevel() {
|
|
|
|
static constexpr uint8_t levtab[] = {
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 12, 16, 20, 24, 28, 32,
|
|
0, 0, 0, 0, 0, 12, 20, 28, 32, 40, 44, 48, 52, 56, 60, 64,
|
|
0, 0, 0, 20, 32, 44, 52, 60, 64, 72, 76, 80, 84, 88, 92, 96,
|
|
0, 0, 32, 52, 64, 76, 84, 92, 96, 104, 108, 112, 116, 120, 124, 128,
|
|
0, 32, 64, 84, 96, 108, 116, 124, 128, 136, 140, 144, 148, 152, 156, 160,
|
|
0, 64, 96, 116, 128, 140, 148, 156, 160, 168, 172, 176, 180, 184, 188, 192,
|
|
0, 96, 128, 148, 160, 172, 180, 188, 192, 200, 204, 208, 212, 216, 220, 224,
|
|
};
|
|
|
|
// This uses a combined value of the top four bits of frequency with the octave/block
|
|
uint16_t i = (Chan->GetOctave() << 4) | (Chan->GetFreq() >> 6);
|
|
KeyScaleLevel = levtab[i] >> KeyScaleShift;
|
|
}
|