aboutsummaryrefslogtreecommitdiff
path: root/src/chips/opal/opal.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/chips/opal/opal.hpp')
-rw-r--r--src/chips/opal/opal.hpp1398
1 files changed, 0 insertions, 1398 deletions
diff --git a/src/chips/opal/opal.hpp b/src/chips/opal/opal.hpp
deleted file mode 100644
index e8110a5..0000000
--- a/src/chips/opal/opal.hpp
+++ /dev/null
@@ -1,1398 +0,0 @@
-/*
-
- 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
-
-*/
-#define OPAL_HAVE_SOFT_PANNING 1 /* libADLMIDI */
-
-
-
-#include <stdint.h>
-
-
-
-//==================================================================================================
-// 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 SetPan(uint8_t pan);
- 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; } /* libADLMIDI */
-
- 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;
- uint16_t LeftPan, RightPan;
- };
-
- public:
- Opal(int sample_rate);
- ~Opal();
-
- void SetSampleRate(int sample_rate);
- void Port(uint16_t reg_num, uint8_t val);
- void Pan(uint16_t reg_num, uint8_t pan);
- 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];
- static const uint16_t PanLawTable[128];
-};
-//--------------------------------------------------------------------------------------------------
-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,
-};
-//--------------------------------------------------------------------------------------------------
-const uint16_t Opal::PanLawTable[128] =
-{
- 65535, 65529, 65514, 65489, 65454, 65409, 65354, 65289,
- 65214, 65129, 65034, 64929, 64814, 64689, 64554, 64410,
- 64255, 64091, 63917, 63733, 63540, 63336, 63123, 62901,
- 62668, 62426, 62175, 61914, 61644, 61364, 61075, 60776,
- 60468, 60151, 59825, 59489, 59145, 58791, 58428, 58057,
- 57676, 57287, 56889, 56482, 56067, 55643, 55211, 54770,
- 54320, 53863, 53397, 52923, 52441, 51951, 51453, 50947,
- 50433, 49912, 49383, 48846, 48302, 47750, 47191,
- 46340, // Center left
- 46340, // Center right
- 45472, 44885, 44291, 43690, 43083, 42469, 41848, 41221,
- 40588, 39948, 39303, 38651, 37994, 37330, 36661, 35986,
- 35306, 34621, 33930, 33234, 32533, 31827, 31116, 30400,
- 29680, 28955, 28225, 27492, 26754, 26012, 25266, 24516,
- 23762, 23005, 22244, 21480, 20713, 19942, 19169, 18392,
- 17613, 16831, 16046, 15259, 14469, 13678, 12884, 12088,
- 11291, 10492, 9691, 8888, 8085, 7280, 6473, 5666,
- 4858, 4050, 3240, 2431, 1620, 810, 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();
-
- // Initialise channel panning at center.
- for (int i = 0; i < NumChannels; i++) {
- Chan[i].SetPan(64);
- Chan[i].SetLeftEnable(true);
- Chan[i].SetRightEnable(true);
- }
-
- 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) {
-
- const int 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 = 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];
-
- /* libADLMIDI: registers Ax and Cx affect both channels */
- Channel *chans[2] = {&chan, chan.GetChannelPair()};
- unsigned numchans = chans[1] ? 2 : 1;
-
- // Do specific registers
- switch (reg_num & 0xF0) {
-
- // Frequency low
- case 0xA0: {
- for (unsigned i = 0; i < numchans; ++i) { /* libADLMIDI */
- chans[i]->SetFrequencyLow(val);
- }
- break;
- }
-
- // Key-on / Octave / Frequency High
- case 0xB0: {
- for (unsigned i = 0; i < numchans; ++i) { /* libADLMIDI */
- 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;
- }
- }
- }
-}
-
-
-
-//==================================================================================================
-// Set panning on the channel designated by the register number.
-// This is extended functionality.
-//==================================================================================================
-void Opal::Pan(uint16_t reg_num, uint8_t pan)
-{
- uint8_t high = (reg_num >> 8) & 1;
- uint8_t regm = reg_num & 0xff;
- Chan[9 * high + (regm & 0x0f)].SetPan(pan);
-}
-
-
-
-//==================================================================================================
-// 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 = (LastOutput[0] * omblend + CurrOutput[0] * SampleAccum) / SampleRate;
- *right = (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 = leftmix;
-
- if (rightmix < -0x8000)
- right = -0x8000;
- else if (rightmix > 0x7FFF)
- right = 0x7FFF;
- else
- right = 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;
-}
-
-
-
-//==================================================================================================
-// 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
- if (clk & 4)
- vibrato = -vibrato; // The second half positions are negative
- }
-
- vibrato <<= Octave;
-
- // 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;
-
- left = left * LeftPan / 65536;
- right = right * RightPan / 65536;
-}
-
-
-
-//==================================================================================================
-// 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;
-}
-
-
-
-//==================================================================================================
-// Pan the channel to the position given.
-//==================================================================================================
-void Opal::Channel::SetPan(uint8_t pan)
-{
- pan &= 127;
- LeftPan = PanLawTable[pan];
- RightPan = PanLawTable[127 - pan];
-}
-
-
-
-//==================================================================================================
-// 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 = (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] + 1024;
- v >>= mix >> 8;
- 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) {
-
- /* libADLMIDI: KSL computation fix */
- const unsigned KeyScaleShiftTable[4] = {8, 1, 2, 0};
- KeyScaleShift = KeyScaleShiftTable[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 = 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 = 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 = 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 const uint16_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;
-}
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-04 23:51:02 +0000