aboutsummaryrefslogtreecommitdiff
path: root/src/chips
diff options
context:
space:
mode:
authorVitaly Novichkov <admin@wohlnet.ru>2018-04-10 02:15:03 +0300
committerVitaly Novichkov <admin@wohlnet.ru>2018-04-10 02:15:03 +0300
commit8a0a939a3281a31fc17327d24f0a4c0975a1b9fa (patch)
treee5f87aba998ede08465aa319af7dba930abff025 /src/chips
parent0ad695eeaaf5d52d3ea4ef15d295d8cc62002a50 (diff)
downloadlibADLMIDI-8a0a939a3281a31fc17327d24f0a4c0975a1b9fa.tar.gz
libADLMIDI-8a0a939a3281a31fc17327d24f0a4c0975a1b9fa.tar.bz2
libADLMIDI-8a0a939a3281a31fc17327d24f0a4c0975a1b9fa.zip
[Experimental] Added support for emulation core switching in real time!
Due to clunky playback on updated Nuked OPL3 emulator v 1.8, I kept the Nuked OPL3 1.7.4 work in parallel and be a separated switchable emulator.
Diffstat (limited to 'src/chips')
-rw-r--r--src/chips/dosbox/dbopl.cpp2045
-rw-r--r--src/chips/dosbox/dbopl.h314
-rw-r--r--src/chips/dosbox_opl3.cpp84
-rw-r--r--src/chips/dosbox_opl3.h23
-rw-r--r--src/chips/nuked/nukedopl3.c1391
-rw-r--r--src/chips/nuked/nukedopl3.h160
-rw-r--r--src/chips/nuked/nukedopl3_174.c1391
-rw-r--r--src/chips/nuked/nukedopl3_174.h154
-rw-r--r--src/chips/nuked/old/nukedopl3.c1391
-rw-r--r--src/chips/nuked/old/nukedopl3.h154
-rw-r--r--src/chips/nuked_opl3.cpp67
-rw-r--r--src/chips/nuked_opl3.h23
-rw-r--r--src/chips/nuked_opl3_v174.cpp67
-rw-r--r--src/chips/nuked_opl3_v174.h23
-rw-r--r--src/chips/opl_chip_base.cpp22
-rw-r--r--src/chips/opl_chip_base.h25
16 files changed, 7334 insertions, 0 deletions
diff --git a/src/chips/dosbox/dbopl.cpp b/src/chips/dosbox/dbopl.cpp
new file mode 100644
index 0000000..8834524
--- /dev/null
+++ b/src/chips/dosbox/dbopl.cpp
@@ -0,0 +1,2045 @@
+//#ifdef ADLMIDI_USE_DOSBOX_OPL
+
+#ifdef __MINGW32__
+typedef struct vswprintf {} swprintf;
+#endif
+/*
+ * Copyright (C) 2002-2010 The DOSBox Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+/*
+ DOSBox implementation of a combined Yamaha YMF262 and Yamaha YM3812 emulator.
+ Enabling the opl3 bit will switch the emulator to stereo opl3 output instead of regular mono opl2
+ Except for the table generation it's all integer math
+ Can choose different types of generators, using muls and bigger tables, try different ones for slower platforms
+ The generation was based on the MAME implementation but tried to have it use less memory and be faster in general
+ MAME uses much bigger envelope tables and this will be the biggest cause of it sounding different at times
+
+ //TODO Don't delay first operator 1 sample in opl3 mode
+ //TODO Maybe not use class method pointers but a regular function pointers with operator as first parameter
+ //TODO Fix panning for the Percussion channels, would any opl3 player use it and actually really change it though?
+ //TODO Check if having the same accuracy in all frequency multipliers sounds better or not
+
+ //DUNNO Keyon in 4op, switch to 2op without keyoff.
+*/
+
+/* $Id: dbopl.cpp,v 1.10 2009-06-10 19:54:51 harekiet Exp $ */
+
+
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+#include "dbopl.h"
+
+#define DB_MAX(x, y) ((x) > (y) ? (x) : (y))
+#define DB_MIN(x, y) ((x) < (y) ? (x) : (y))
+
+#define DBOPL_CLAMP(V, MIN, MAX) DB_MAX(DB_MIN(V, (MAX)), (MIN))
+
+#ifndef PI
+#define PI 3.14159265358979323846
+#endif
+
+namespace DBOPL
+{
+
+#define OPLRATE ((double)(14318180.0 / 288.0))
+#define TREMOLO_TABLE 52
+
+ //Try to use most precision for frequencies
+ //Else try to keep different waves in synch
+ //#define WAVE_PRECISION 1
+ #ifndef WAVE_PRECISION
+ //Wave bits available in the top of the 32bit range
+ //Original adlib uses 10.10, we use 10.22
+#define WAVE_BITS 10
+ #else
+ //Need some extra bits at the top to have room for octaves and frequency multiplier
+ //We support to 8 times lower rate
+ //128 * 15 * 8 = 15350, 2^13.9, so need 14 bits
+#define WAVE_BITS 14
+ #endif
+#define WAVE_SH ( 32 - WAVE_BITS )
+#define WAVE_MASK ( ( 1 << WAVE_SH ) - 1 )
+
+ //Use the same accuracy as the waves
+#define LFO_SH ( WAVE_SH - 10 )
+ //LFO is controlled by our tremolo 256 sample limit
+#define LFO_MAX ( 256 << ( LFO_SH ) )
+
+
+ //Maximum amount of attenuation bits
+ //Envelope goes to 511, 9 bits
+ #if (DBOPL_WAVE == WAVE_TABLEMUL )
+ //Uses the value directly
+#define ENV_BITS ( 9 )
+ #else
+ //Add 3 bits here for more accuracy and would have to be shifted up either way
+#define ENV_BITS ( 9 )
+ #endif
+ //Limits of the envelope with those bits and when the envelope goes silent
+#define ENV_MIN 0
+#define ENV_EXTRA ( ENV_BITS - 9 )
+#define ENV_MAX ( 511 << ENV_EXTRA )
+#define ENV_LIMIT ( ( 12 * 256) >> ( 3 - ENV_EXTRA ) )
+#define ENV_SILENT( _X_ ) ( (_X_) >= ENV_LIMIT )
+
+ //Attack/decay/release rate counter shift
+#define RATE_SH 24
+#define RATE_MASK ( ( 1 << RATE_SH ) - 1 )
+ //Has to fit within 16bit lookuptable
+#define MUL_SH 16
+
+ //Check some ranges
+ #if ENV_EXTRA > 3
+#error Too many envelope bits
+ #endif
+
+
+ //How much to substract from the base value for the final attenuation
+ static const Bit8u KslCreateTable[16] =
+ {
+ //0 will always be be lower than 7 * 8
+ 64, 32, 24, 19,
+ 16, 12, 11, 10,
+ 8, 6, 5, 4,
+ 3, 2, 1, 0,
+ };
+
+#define M(_X_) ((Bit8u)( (_X_) * 2))
+ static const Bit8u FreqCreateTable[16] =
+ {
+ M(0.5), M(1), M(2), M(3), M(4), M(5), M(6), M(7),
+ M(8), M(9), M(10), M(10), M(12), M(12), M(15), M(15)
+ };
+#undef M
+
+ //We're not including the highest attack rate, that gets a special value
+ static const Bit8u AttackSamplesTable[13] =
+ {
+ 69, 55, 46, 40,
+ 35, 29, 23, 20,
+ 19, 15, 11, 10,
+ 9
+ };
+ //On a real opl these values take 8 samples to reach and are based upon larger tables
+ static const Bit8u EnvelopeIncreaseTable[13] =
+ {
+ 4, 5, 6, 7,
+ 8, 10, 12, 14,
+ 16, 20, 24, 28,
+ 32,
+ };
+
+ #if ( DBOPL_WAVE == WAVE_HANDLER ) || ( DBOPL_WAVE == WAVE_TABLELOG )
+ static Bit16u ExpTable[ 256 ];
+ #endif
+
+ #if ( DBOPL_WAVE == WAVE_HANDLER )
+ //PI table used by WAVEHANDLER
+ static Bit16u SinTable[ 512 ];
+ #endif
+
+ #if ( DBOPL_WAVE > WAVE_HANDLER )
+ //Layout of the waveform table in 512 entry intervals
+ //With overlapping waves we reduce the table to half it's size
+
+ // | |//\\|____|WAV7|//__|/\ |____|/\/\|
+ // |\\//| | |WAV7| | \/| | |
+ // |06 |0126|17 |7 |3 |4 |4 5 |5 |
+
+ //6 is just 0 shifted and masked
+
+ static Bit16s WaveTable[ 8 * 512 ];
+ //Distance into WaveTable the wave starts
+ static const Bit16u WaveBaseTable[8] =
+ {
+ 0x000, 0x200, 0x200, 0x800,
+ 0xa00, 0xc00, 0x100, 0x400,
+
+ };
+ //Mask the counter with this
+ static const Bit16u WaveMaskTable[8] =
+ {
+ 1023, 1023, 511, 511,
+ 1023, 1023, 512, 1023,
+ };
+
+ //Where to start the counter on at keyon
+ static const Bit16u WaveStartTable[8] =
+ {
+ 512, 0, 0, 0,
+ 0, 512, 512, 256,
+ };
+ #endif
+
+ #if ( DBOPL_WAVE == WAVE_TABLEMUL )
+ static Bit16u MulTable[ 384 ];
+ #endif
+
+ static Bit8u KslTable[ 8 * 16 ];
+ static Bit8u TremoloTable[ TREMOLO_TABLE ];
+ //Start of a channel behind the chip struct start
+ static Bit16u ChanOffsetTable[32];
+ //Start of an operator behind the chip struct start
+ static Bit16u OpOffsetTable[64];
+
+ //The lower bits are the shift of the operator vibrato value
+ //The highest bit is right shifted to generate -1 or 0 for negation
+ //So taking the highest input value of 7 this gives 3, 7, 3, 0, -3, -7, -3, 0
+ static const Bit8s VibratoTable[ 8 ] =
+ {
+ 1 - 0x00, 0 - 0x00, 1 - 0x00, 30 - 0x00,
+ 1 - 0x80, 0 - 0x80, 1 - 0x80, 30 - 0x80
+ };
+
+ //Shift strength for the ksl value determined by ksl strength
+ static const Bit8u KslShiftTable[4] =
+ {
+ 31, 1, 2, 0
+ };
+
+ //Generate a table index and table shift value using input value from a selected rate
+ static void EnvelopeSelect(Bit8u val, Bit8u &index, Bit8u &shift)
+ {
+ if(val < 13 * 4) //Rate 0 - 12
+ {
+ shift = 12 - (val >> 2);
+ index = val & 3;
+ }
+ else if(val < 15 * 4) //rate 13 - 14
+ {
+ shift = 0;
+ index = val - 12 * 4;
+ }
+ else //rate 15 and up
+ {
+ shift = 0;
+ index = 12;
+ }
+ }
+
+ #if ( DBOPL_WAVE == WAVE_HANDLER )
+ /*
+ Generate the different waveforms out of the sine/exponetial table using handlers
+ */
+ static inline Bits MakeVolume(Bitu wave, Bitu volume)
+ {
+ Bitu total = wave + volume;
+ Bitu index = total & 0xff;
+ Bitu sig = ExpTable[ index ];
+ Bitu exp = total >> 8;
+ #if 0
+
+ //Check if we overflow the 31 shift limit
+ if(exp >= 32)
+ LOG_MSG("WTF %d %d", total, exp);
+
+ #endif
+ return (sig >> exp);
+ };
+
+ static Bits DB_FASTCALL WaveForm0(Bitu i, Bitu volume)
+ {
+ Bits neg = 0 - ((i >> 9) & 1); //Create ~0 or 0
+ Bitu wave = SinTable[i & 511];
+ return (MakeVolume(wave, volume) ^ neg) - neg;
+ }
+ static Bits DB_FASTCALL WaveForm1(Bitu i, Bitu volume)
+ {
+ Bit32u wave = SinTable[i & 511];
+ wave |= (((i ^ 512) & 512) - 1) >> (32 - 12);
+ return MakeVolume(wave, volume);
+ }
+ static Bits DB_FASTCALL WaveForm2(Bitu i, Bitu volume)
+ {
+ Bitu wave = SinTable[i & 511];
+ return MakeVolume(wave, volume);
+ }
+ static Bits DB_FASTCALL WaveForm3(Bitu i, Bitu volume)
+ {
+ Bitu wave = SinTable[i & 255];
+ wave |= (((i ^ 256) & 256) - 1) >> (32 - 12);
+ return MakeVolume(wave, volume);
+ }
+ static Bits DB_FASTCALL WaveForm4(Bitu i, Bitu volume)
+ {
+ //Twice as fast
+ i <<= 1;
+ Bits neg = 0 - ((i >> 9) & 1); //Create ~0 or 0
+ Bitu wave = SinTable[i & 511];
+ wave |= (((i ^ 512) & 512) - 1) >> (32 - 12);
+ return (MakeVolume(wave, volume) ^ neg) - neg;
+ }
+ static Bits DB_FASTCALL WaveForm5(Bitu i, Bitu volume)
+ {
+ //Twice as fast
+ i <<= 1;
+ Bitu wave = SinTable[i & 511];
+ wave |= (((i ^ 512) & 512) - 1) >> (32 - 12);
+ return MakeVolume(wave, volume);
+ }
+ static Bits DB_FASTCALL WaveForm6(Bitu i, Bitu volume)
+ {
+ Bits neg = 0 - ((i >> 9) & 1); //Create ~0 or 0
+ return (MakeVolume(0, volume) ^ neg) - neg;
+ }
+ static Bits DB_FASTCALL WaveForm7(Bitu i, Bitu volume)
+ {
+ //Negative is reversed here
+ Bits neg = ((i >> 9) & 1) - 1;
+ Bitu wave = (i << 3);
+ //When negative the volume also runs backwards
+ wave = ((wave ^ neg) - neg) & 4095;
+ return (MakeVolume(wave, volume) ^ neg) - neg;
+ }
+
+ static const WaveHandler WaveHandlerTable[8] =
+ {
+ WaveForm0, WaveForm1, WaveForm2, WaveForm3,
+ WaveForm4, WaveForm5, WaveForm6, WaveForm7
+ };
+
+ #endif
+
+ /*
+ Operator
+ */
+
+ //We zero out when rate == 0
+ inline void Operator::UpdateAttack(const Chip *chip)
+ {
+ Bit8u rate = reg60 >> 4;
+
+ if(rate)
+ {
+ Bit8u val = (rate << 2) + ksr;
+ attackAdd = chip->attackRates[ val ];
+ rateZero &= ~(1 << ATTACK);
+ }
+ else
+ {
+ attackAdd = 0;
+ rateZero |= (1 << ATTACK);
+ }
+ }
+ inline void Operator::UpdateDecay(const Chip *chip)
+ {
+ Bit8u rate = reg60 & 0xf;
+
+ if(rate)
+ {
+ Bit8u val = (rate << 2) + ksr;
+ decayAdd = chip->linearRates[ val ];
+ rateZero &= ~(1 << DECAY);
+ }
+ else
+ {
+ decayAdd = 0;
+ rateZero |= (1 << DECAY);
+ }
+ }
+ inline void Operator::UpdateRelease(const Chip *chip)
+ {
+ Bit8u rate = reg80 & 0xf;
+
+ if(rate)
+ {
+ Bit8u val = (rate << 2) + ksr;
+ releaseAdd = chip->linearRates[ val ];
+ rateZero &= ~(1 << RELEASE);
+
+ if(!(reg20 & MASK_SUSTAIN))
+ rateZero &= ~(1 << SUSTAIN);
+ }
+ else
+ {
+ rateZero |= (1 << RELEASE);
+ releaseAdd = 0;
+
+ if(!(reg20 & MASK_SUSTAIN))
+ rateZero |= (1 << SUSTAIN);
+ }
+ }
+
+ inline void Operator::UpdateAttenuation()
+ {
+ Bit8u kslBase = (Bit8u)((chanData >> SHIFT_KSLBASE) & 0xff);
+ Bit32u tl = reg40 & 0x3f;
+ Bit8u kslShift = KslShiftTable[ reg40 >> 6 ];
+ //Make sure the attenuation goes to the right bits
+ totalLevel = tl << (ENV_BITS - 7); //Total level goes 2 bits below max
+ totalLevel += (kslBase << ENV_EXTRA) >> kslShift;
+ }
+
+ void Operator::UpdateFrequency()
+ {
+ Bit32u freq = chanData & ((1 << 10) - 1);
+ Bit32u block = (chanData >> 10) & 0xff;
+ #ifdef WAVE_PRECISION
+ block = 7 - block;
+ waveAdd = (freq * freqMul) >> block;
+ #else
+ waveAdd = (freq << block) * freqMul;
+ #endif
+
+ if(reg20 & MASK_VIBRATO)
+ {
+ vibStrength = (Bit8u)(freq >> 7);
+ #ifdef WAVE_PRECISION
+ vibrato = (vibStrength * freqMul) >> block;
+ #else
+ vibrato = (vibStrength << block) * freqMul;
+ #endif
+ }
+ else
+ {
+ vibStrength = 0;
+ vibrato = 0;
+ }
+ }
+
+ void Operator::UpdateRates(const Chip *chip)
+ {
+ //Mame seems to reverse this where enabling ksr actually lowers
+ //the rate, but pdf manuals says otherwise?
+ Bit8u newKsr = (Bit8u)((chanData >> SHIFT_KEYCODE) & 0xff);
+
+ if(!(reg20 & MASK_KSR))
+ newKsr >>= 2;
+
+ if(ksr == newKsr)
+ return;
+
+ ksr = newKsr;
+ UpdateAttack(chip);
+ UpdateDecay(chip);
+ UpdateRelease(chip);
+ }
+
+ INLINE Bit32s Operator::RateForward(Bit32u add)
+ {
+ rateIndex += add;
+ Bit32s ret = rateIndex >> RATE_SH;
+ rateIndex = rateIndex & RATE_MASK;
+ return ret;
+ }
+
+ template< Operator::State yes>
+ Bits Operator::TemplateVolume()
+ {
+ Bit32s vol = volume;
+ Bit32s change;
+
+ switch(yes)
+ {
+ case OFF:
+ return ENV_MAX;
+
+ case ATTACK:
+ change = RateForward(attackAdd);
+
+ if(!change)
+ return vol;
+
+ vol += ((~vol) * change) >> 3;
+
+ if(vol < ENV_MIN)
+ {
+ volume = ENV_MIN;
+ rateIndex = 0;
+ SetState(DECAY);
+ return ENV_MIN;
+ }
+
+ break;
+
+ case DECAY:
+ vol += RateForward(decayAdd);
+
+ if(GCC_UNLIKELY(vol >= sustainLevel))
+ {
+ //Check if we didn't overshoot max attenuation, then just go off
+ if(GCC_UNLIKELY(vol >= ENV_MAX))
+ {
+ volume = ENV_MAX;
+ SetState(OFF);
+ return ENV_MAX;
+ }
+
+ //Continue as sustain
+ rateIndex = 0;
+ SetState(SUSTAIN);
+ }
+
+ break;
+
+ case SUSTAIN:
+ if(reg20 & MASK_SUSTAIN)
+ return vol;
+
+ //In sustain phase, but not sustaining, do regular release
+ case RELEASE:
+ vol += RateForward(releaseAdd);;
+
+ if(GCC_UNLIKELY(vol >= ENV_MAX))
+ {
+ volume = ENV_MAX;
+ SetState(OFF);
+ return ENV_MAX;
+ }
+
+ break;
+ }
+
+ volume = vol;
+ return vol;
+ }
+
+ static const VolumeHandler VolumeHandlerTable[5] =
+ {
+ &Operator::TemplateVolume< Operator::OFF >,
+ &Operator::TemplateVolume< Operator::RELEASE >,
+ &Operator::TemplateVolume< Operator::SUSTAIN >,
+ &Operator::TemplateVolume< Operator::DECAY >,
+ &Operator::TemplateVolume< Operator::ATTACK >
+ };
+
+ INLINE Bitu Operator::ForwardVolume()
+ {
+ return currentLevel + (this->*volHandler)();
+ }
+
+
+ INLINE Bitu Operator::ForwardWave()
+ {
+ waveIndex += waveCurrent;
+ return waveIndex >> WAVE_SH;
+ }
+
+ void Operator::Write20(const Chip *chip, Bit8u val)
+ {
+ Bit8u change = (reg20 ^ val);
+
+ if(!change)
+ return;
+
+ reg20 = val;
+ //Shift the tremolo bit over the entire register, saved a branch, YES!
+ tremoloMask = (Bit8s)(val) >> 7;
+ tremoloMask &= ~((1 << ENV_EXTRA) - 1);
+
+ //Update specific features based on changes
+ if(change & MASK_KSR)
+ UpdateRates(chip);
+
+ //With sustain enable the volume doesn't change
+ if(reg20 & MASK_SUSTAIN || (!releaseAdd))
+ rateZero |= (1 << SUSTAIN);
+ else
+ rateZero &= ~(1 << SUSTAIN);
+
+ //Frequency multiplier or vibrato changed
+ if(change & (0xf | MASK_VIBRATO))
+ {
+ freqMul = chip->freqMul[ val & 0xf ];
+ UpdateFrequency();
+ }
+ }
+
+ void Operator::Write40(const Chip * /*chip*/, Bit8u val)
+ {
+ if(!(reg40 ^ val))
+ return;
+
+ reg40 = val;
+ UpdateAttenuation();
+ }
+
+ void Operator::Write60(const Chip *chip, Bit8u val)
+ {
+ Bit8u change = reg60 ^ val;
+ reg60 = val;
+
+ if(change & 0x0f)
+ UpdateDecay(chip);
+
+ if(change & 0xf0)
+ UpdateAttack(chip);
+ }
+
+ void Operator::Write80(const Chip *chip, Bit8u val)
+ {
+ Bit8u change = (reg80 ^ val);
+
+ if(!change)
+ return;
+
+ reg80 = val;
+ Bit8u sustain = val >> 4;
+ //Turn 0xf into 0x1f
+ sustain |= (sustain + 1) & 0x10;
+ sustainLevel = sustain << (ENV_BITS - 5);
+
+ if(change & 0x0f)
+ UpdateRelease(chip);
+ }
+
+ void Operator::WriteE0(const Chip *chip, Bit8u val)
+ {
+ if(!(regE0 ^ val))
+ return;
+
+ //in opl3 mode you can always selet 7 waveforms regardless of waveformselect
+ Bit8u waveForm = val & ((0x3 & chip->waveFormMask) | (0x7 & chip->opl3Active));
+ regE0 = val;
+ #if ( DBOPL_WAVE == WAVE_HANDLER )
+ waveHandler = WaveHandlerTable[ waveForm ];
+ #else
+ waveBase = WaveTable + WaveBaseTable[ waveForm ];
+ waveStart = WaveStartTable[ waveForm ] << WAVE_SH;
+ waveMask = WaveMaskTable[ waveForm ];
+ #endif
+ }
+
+ INLINE void Operator::SetState(Bit8u s)
+ {
+ state = s;
+ volHandler = VolumeHandlerTable[ s ];
+ }
+
+ INLINE bool Operator::Silent() const
+ {
+ if(!ENV_SILENT(totalLevel + volume))
+ return false;
+
+ if(!(rateZero & (1 << state)))
+ return false;
+
+ return true;
+ }
+
+ INLINE void Operator::Prepare(const Chip *chip)
+ {
+ currentLevel = totalLevel + (chip->tremoloValue & tremoloMask);
+ waveCurrent = waveAdd;
+
+ if(vibStrength >> chip->vibratoShift)
+ {
+ Bit32s add = vibrato >> chip->vibratoShift;
+ //Sign extend over the shift value
+ Bit32s neg = chip->vibratoSign;
+ //Negate the add with -1 or 0
+ add = (add ^ neg) - neg;
+ waveCurrent += add;
+ }
+ }
+
+ void Operator::KeyOn(Bit8u mask)
+ {
+ if(!keyOn)
+ {
+ //Restart the frequency generator
+ #if ( DBOPL_WAVE > WAVE_HANDLER )
+ waveIndex = waveStart;
+ #else
+ waveIndex = 0;
+ #endif
+ rateIndex = 0;
+ SetState(ATTACK);
+ }
+
+ keyOn |= mask;
+ }
+
+ void Operator::KeyOff(Bit8u mask)
+ {
+ keyOn &= ~mask;
+
+ if(!keyOn)
+ {
+ if(state != OFF)
+ SetState(RELEASE);
+ }
+ }
+
+ INLINE Bits Operator::GetWave(Bitu index, Bitu vol)
+ {
+ #if ( DBOPL_WAVE == WAVE_HANDLER )
+ return waveHandler(index, vol << (3 - ENV_EXTRA));
+ #elif ( DBOPL_WAVE == WAVE_TABLEMUL )
+ return (waveBase[ index & waveMask ] * MulTable[ vol >> ENV_EXTRA ]) >> MUL_SH;
+ #elif ( DBOPL_WAVE == WAVE_TABLELOG )
+ Bit32s wave = waveBase[ index & waveMask ];
+ Bit32u total = (wave & 0x7fff) + vol << (3 - ENV_EXTRA);
+ Bit32s sig = ExpTable[ total & 0xff ];
+ Bit32u exp = total >> 8;
+ Bit32s neg = wave >> 16;
+ return ((sig ^ neg) - neg) >> exp;
+ #else
+#error "No valid wave routine"
+ #endif
+ }
+
+ Bits INLINE Operator::GetSample(Bits modulation)
+ {
+ Bitu vol = ForwardVolume();
+
+ if(ENV_SILENT(vol))
+ {
+ //Simply forward the wave
+ waveIndex += waveCurrent;
+ return 0;
+ }
+ else
+ {
+ Bitu index = ForwardWave();
+ index += modulation;
+ return GetWave(index, vol);
+ }
+ }
+
+ Operator::Operator()
+ {
+ chanData = 0;
+ freqMul = 0;
+ waveIndex = 0;
+ waveAdd = 0;
+ waveCurrent = 0;
+ keyOn = 0;
+ ksr = 0;
+ reg20 = 0;
+ reg40 = 0;
+ reg60 = 0;
+ reg80 = 0;
+ regE0 = 0;
+ SetState(OFF);
+ rateZero = (1 << OFF);
+ sustainLevel = ENV_MAX;
+ currentLevel = ENV_MAX;
+ totalLevel = ENV_MAX;
+ volume = ENV_MAX;
+ releaseAdd = 0;
+ }
+
+ /*
+ Channel
+ */
+
+ Channel::Channel()
+ {
+ old[0] = old[1] = 0;
+ chanData = 0;
+ regB0 = 0;
+ regC0 = 0;
+ maskLeft = -1;
+ maskRight = -1;
+ feedback = 31;
+ fourMask = 0;
+ synthHandler = &Channel::BlockTemplate< sm2FM >;
+ }
+
+ void Channel::SetChanData(const Chip *chip, Bit32u data)
+ {
+ Bit32u change = chanData ^ data;
+ chanData = data;
+ Op(0)->chanData = data;
+ Op(1)->chanData = data;
+ //Since a frequency update triggered this, always update frequency
+ Op(0)->UpdateFrequency();
+ Op(1)->UpdateFrequency();
+
+ if(change & (0xff << SHIFT_KSLBASE))
+ {
+ Op(0)->UpdateAttenuation();
+ Op(1)->UpdateAttenuation();
+ }
+
+ if(change & (0xff << SHIFT_KEYCODE))
+ {
+ Op(0)->UpdateRates(chip);
+ Op(1)->UpdateRates(chip);
+ }
+ }
+
+ void Channel::UpdateFrequency(const Chip *chip, Bit8u fourOp)
+ {
+ //Extrace the frequency bits
+ Bit32u data = chanData & 0xffff;
+ Bit32u kslBase = KslTable[ data >> 6 ];
+ Bit32u keyCode = (data & 0x1c00) >> 9;
+
+ if(chip->reg08 & 0x40)
+ {
+ keyCode |= (data & 0x100) >> 8; /* notesel == 1 */
+ }
+ else
+ {
+ keyCode |= (data & 0x200) >> 9; /* notesel == 0 */
+ }
+
+ //Add the keycode and ksl into the highest bits of chanData
+ data |= (keyCode << SHIFT_KEYCODE) | (kslBase << SHIFT_KSLBASE);
+ (this + 0)->SetChanData(chip, data);
+
+ if(fourOp & 0x3f)
+ (this + 1)->SetChanData(chip, data);
+ }
+
+ void Channel::WriteA0(const Chip *chip, Bit8u val)
+ {
+ Bit8u fourOp = chip->reg104 & chip->opl3Active & fourMask;
+
+ //Don't handle writes to silent fourop channels
+ if(fourOp > 0x80)
+ return;
+
+ Bit32u change = (chanData ^ val) & 0xff;
+
+ if(change)
+ {
+ chanData ^= change;
+ UpdateFrequency(chip, fourOp);
+ }
+ }
+
+ void Channel::WriteB0(const Chip *chip, Bit8u val)
+ {
+ Bit8u fourOp = chip->reg104 & chip->opl3Active & fourMask;
+
+ //Don't handle writes to silent fourop channels
+ if(fourOp > 0x80)
+ return;
+
+ Bitu change = (chanData ^ (val << 8)) & 0x1f00;
+
+ if(change)
+ {
+ chanData ^= change;
+ UpdateFrequency(chip, fourOp);
+ }
+
+ //Check for a change in the keyon/off state
+ if(!((val ^ regB0) & 0x20))
+ return;
+
+ regB0 = val;
+
+ if(val & 0x20)
+ {
+ Op(0)->KeyOn(0x1);
+ Op(1)->KeyOn(0x1);
+
+ if(fourOp & 0x3f)
+ {
+ (this + 1)->Op(0)->KeyOn(1);
+ (this + 1)->Op(1)->KeyOn(1);
+ }
+ }
+ else
+ {
+ Op(0)->KeyOff(0x1);
+ Op(1)->KeyOff(0x1);
+
+ if(fourOp & 0x3f)
+ {
+ (this + 1)->Op(0)->KeyOff(1);
+ (this + 1)->Op(1)->KeyOff(1);
+ }
+ }
+ }
+
+ void Channel::WriteC0(const Chip *chip, Bit8u val)
+ {
+ Bit8u change = val ^ regC0;
+
+ if(!change)
+ return;
+
+ regC0 = val;
+ feedback = (val >> 1) & 7;
+
+ if(feedback)
+ {
+ //We shift the input to the right 10 bit wave index value
+ feedback = 9 - feedback;
+ }
+ else
+ feedback = 31;
+
+ //Select the new synth mode
+ if(chip->opl3Active)
+ {
+ //4-op mode enabled for this channel
+ if((chip->reg104 & fourMask) & 0x3f)
+ {
+ Channel *chan0, *chan1;
+
+ //Check if it's the 2nd channel in a 4-op
+ if(!(fourMask & 0x80))
+ {
+ chan0 = this;
+ chan1 = this + 1;
+ }
+ else
+ {
+ chan0 = this - 1;
+ chan1 = this;
+ }
+
+ Bit8u synth = ((chan0->regC0 & 1) << 0) | ((chan1->regC0 & 1) << 1);
+
+ switch(synth)
+ {
+ case 0:
+ chan0->synthHandler = &Channel::BlockTemplate< sm3FMFM >;
+ break;
+
+ case 1:
+ chan0->synthHandler = &Channel::BlockTemplate< sm3AMFM >;
+ break;
+
+ case 2:
+ chan0->synthHandler = &Channel::BlockTemplate< sm3FMAM >;
+ break;
+
+ case 3:
+ chan0->synthHandler = &Channel::BlockTemplate< sm3AMAM >;
+ break;
+ }
+
+ //Disable updating percussion channels
+ }
+ else if((fourMask & 0x40) && (chip->regBD & 0x20))
+ {
+ //Regular dual op, am or fm
+ }
+ else if(val & 1)
+ synthHandler = &Channel::BlockTemplate< sm3AM >;
+ else
+ synthHandler = &Channel::BlockTemplate< sm3FM >;
+
+ maskLeft = (val & 0x10) ? -1 : 0;
+ maskRight = (val & 0x20) ? -1 : 0;
+ //opl2 active
+ }
+ else
+ {
+ //Disable updating percussion channels
+ if((fourMask & 0x40) && (chip->regBD & 0x20))
+ {
+ //Regular dual op, am or fm
+ }
+ else if(val & 1)
+ synthHandler = &Channel::BlockTemplate< sm2AM >;
+ else
+ synthHandler = &Channel::BlockTemplate< sm2FM >;
+ }
+ }
+
+ void Channel::ResetC0(const Chip *chip)
+ {
+ Bit8u val = regC0;
+ regC0 ^= 0xff;
+ WriteC0(chip, val);
+ }
+
+ template< bool opl3Mode>
+ INLINE void Channel::GeneratePercussion(Chip *chip, Bit32s *output)
+ {
+ Channel *chan = this;
+ //BassDrum
+ Bit32s mod = (Bit32u)((old[0] + old[1])) >> feedback;
+ old[0] = old[1];
+ old[1] = Op(0)->GetSample(mod);
+
+ //When bassdrum is in AM mode first operator is ignoed
+ if(chan->regC0 & 1)
+ mod = 0;
+ else
+ mod = old[0];
+
+ Bit32s sample = Op(1)->GetSample(mod);
+ //Precalculate stuff used by other outputs
+ Bit32u noiseBit = chip->ForwardNoise() & 0x1;
+ Bit32u c2 = Op(2)->ForwardWave();
+ Bit32u c5 = Op(5)->ForwardWave();
+ Bit32u phaseBit = (((c2 & 0x88) ^ ((c2 << 5) & 0x80)) | ((c5 ^ (c5 << 2)) & 0x20)) ? 0x02 : 0x00;
+ //Hi-Hat
+ Bit32u hhVol = Op(2)->ForwardVolume();
+
+ if(!ENV_SILENT(hhVol))
+ {
+ Bit32u hhIndex = (phaseBit << 8) | (0x34 << (phaseBit ^ (noiseBit << 1)));
+ sample += Op(2)->GetWave(hhIndex, hhVol);
+ }
+
+ //Snare Drum
+ Bit32u sdVol = Op(3)->ForwardVolume();
+
+ if(!ENV_SILENT(sdVol))
+ {
+ Bit32u sdIndex = (0x100 + (c2 & 0x100)) ^ (noiseBit << 8);
+ sample += Op(3)->GetWave(sdIndex, sdVol);
+ }
+
+ //Tom-tom
+ sample += Op(4)->GetSample(0);
+ //Top-Cymbal
+ Bit32u tcVol = Op(5)->ForwardVolume();
+
+ if(!ENV_SILENT(tcVol))
+ {
+ Bit32u tcIndex = (1 + phaseBit) << 8;
+ sample += Op(5)->GetWave(tcIndex, tcVol);
+ }
+
+ sample <<= 1;
+
+ if(opl3Mode)
+ {
+ output[0] += sample;
+ output[1] += sample;
+ }
+ else
+ output[0] += sample;
+ }
+
+ template<SynthMode mode>
+ Channel *Channel::BlockTemplate(Chip *chip, Bit32u samples, Bit32s *output)
+ {
+ switch(mode)
+ {
+ case sm2AM:
+ case sm3AM:
+ if(Op(0)->Silent() && Op(1)->Silent())
+ {
+ old[0] = old[1] = 0;
+ return (this + 1);
+ }
+
+ break;
+
+ case sm2FM:
+ case sm3FM:
+ if(Op(1)->Silent())
+ {
+ old[0] = old[1] = 0;
+ return (this + 1);
+ }
+
+ break;
+
+ case sm3FMFM:
+ if(Op(3)->Silent())
+ {
+ old[0] = old[1] = 0;
+ return (this + 2);
+ }
+
+ break;
+
+ case sm3AMFM:
+ if(Op(0)->Silent() && Op(3)->Silent())
+ {
+ old[0] = old[1] = 0;
+ return (this + 2);
+ }
+
+ break;
+
+ case sm3FMAM:
+ if(Op(1)->Silent() && Op(3)->Silent())
+ {
+ old[0] = old[1] = 0;
+ return (this + 2);
+ }
+
+ break;
+
+ case sm3AMAM:
+ if(Op(0)->Silent() && Op(2)->Silent() && Op(3)->Silent())
+ {
+ old[0] = old[1] = 0;
+ return (this + 2);
+ }
+
+ break;
+
+ default:
+ break;
+ }
+
+ //Init the operators with the the current vibrato and tremolo values
+ Op(0)->Prepare(chip);
+ Op(1)->Prepare(chip);
+
+ if(mode > sm4Start)
+ {
+ Op(2)->Prepare(chip);
+ Op(3)->Prepare(chip);
+ }
+
+ if(mode > sm6Start)
+ {
+ Op(4)->Prepare(chip);
+ Op(5)->Prepare(chip);
+ }
+
+ for(Bitu i = 0; i < samples; i++)
+ {
+ //Early out for percussion handlers
+ if(mode == sm2Percussion)
+ {
+ GeneratePercussion<false>(chip, output + i);
+ continue; //Prevent some unitialized value bitching
+ }
+ else if(mode == sm3Percussion)
+ {
+ GeneratePercussion<true>(chip, output + i * 2);
+ continue; //Prevent some unitialized value bitching
+ }
+
+ //Do unsigned shift so we can shift out all bits but still stay in 10 bit range otherwise
+ Bit32s mod = (Bit32u)((old[0] + old[1])) >> feedback;
+ old[0] = old[1];
+ old[1] = Op(0)->GetSample(mod);
+ Bit32s sample;
+ Bit32s out0 = old[0];
+
+ if(mode == sm2AM || mode == sm3AM)
+ sample = out0 + Op(1)->GetSample(0);
+ else if(mode == sm2FM || mode == sm3FM)
+ sample = Op(1)->GetSample(out0);
+ else if(mode == sm3FMFM)
+ {
+ Bits next = Op(1)->GetSample(out0);
+ next = Op(2)->GetSample(next);
+ sample = Op(3)->GetSample(next);
+ }
+ else if(mode == sm3AMFM)
+ {
+ sample = out0;
+ Bits next = Op(1)->GetSample(0);
+ next = Op(2)->GetSample(next);
+ sample += Op(3)->GetSample(next);
+ }
+ else if(mode == sm3FMAM)
+ {
+ sample = Op(1)->GetSample(out0);
+ Bits next = Op(2)->GetSample(0);
+ sample += Op(3)->GetSample(next);
+ }
+ else if(mode == sm3AMAM)
+ {
+ sample = out0;
+ Bits next = Op(1)->GetSample(0);
+ sample += Op(2)->GetSample(next);
+ sample += Op(3)->GetSample(0);
+ }
+
+ switch(mode)
+ {
+ case sm2AM:
+ case sm2FM:
+ output[ i ] += sample;
+ break;
+
+ case sm3AM:
+ case sm3FM:
+ case sm3FMFM:
+ case sm3AMFM:
+ case sm3FMAM:
+ case sm3AMAM:
+ output[ i * 2 + 0 ] += sample & maskLeft;
+ output[ i * 2 + 1 ] += sample & maskRight;
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ switch(mode)
+ {
+ case sm2AM:
+ case sm2FM:
+ case sm3AM:
+ case sm3FM:
+ return (this + 1);
+
+ case sm3FMFM:
+ case sm3AMFM:
+ case sm3FMAM:
+ case sm3AMAM:
+ return(this + 2);
+
+ case sm2Percussion:
+ case sm3Percussion:
+ return(this + 3);
+ }
+
+ return 0;
+ }
+
+ /*
+ Chip
+ */
+
+ Chip::Chip()
+ {
+ reg08 = 0;
+ reg04 = 0;
+ regBD = 0;
+ reg104 = 0;
+ opl3Active = 0;
+ //Extra zeros!
+ vibratoIndex = 0;
+ tremoloIndex = 0;
+ vibratoSign = 0;
+ vibratoShift = 0;
+ tremoloValue = 0;
+ vibratoStrength = 0;
+ tremoloStrength = 0;
+ waveFormMask = 0;
+ lfoCounter = 0;
+ lfoAdd = 0;
+ noiseCounter = 0;
+ noiseAdd = 0;
+ noiseValue = 0;
+ memset(freqMul, 0, sizeof(Bit32u) * 16);
+ memset(linearRates, 0, sizeof(Bit32u) * 76);
+ memset(attackRates, 0, sizeof(Bit32u) * 76);
+ }
+
+ INLINE Bit32u Chip::ForwardNoise()
+ {
+ noiseCounter += noiseAdd;
+ Bitu count = noiseCounter >> LFO_SH;
+ noiseCounter &= WAVE_MASK;
+
+ for(; count > 0; --count)
+ {
+ //Noise calculation from mame
+ noiseValue ^= (0x800302) & (0 - (noiseValue & 1));
+ noiseValue >>= 1;
+ }
+
+ return noiseValue;
+ }
+
+ INLINE Bit32u Chip::ForwardLFO(Bit32u samples)
+ {
+ //Current vibrato value, runs 4x slower than tremolo
+ vibratoSign = (VibratoTable[ vibratoIndex >> 2]) >> 7;
+ vibratoShift = (VibratoTable[ vibratoIndex >> 2] & 7) + vibratoStrength;
+ tremoloValue = TremoloTable[ tremoloIndex ] >> tremoloStrength;
+ //Check hom many samples there can be done before the value changes
+ Bit32u todo = LFO_MAX - lfoCounter;
+ Bit32u count = (todo + lfoAdd - 1) / lfoAdd;
+
+ if(count > samples)
+ {
+ count = samples;
+ lfoCounter += count * lfoAdd;
+ }
+ else
+ {
+ lfoCounter += count * lfoAdd;
+ lfoCounter &= (LFO_MAX - 1);
+ //Maximum of 7 vibrato value * 4
+ vibratoIndex = (vibratoIndex + 1) & 31;
+
+ //Clip tremolo to the the table size
+ if(tremoloIndex + 1 < TREMOLO_TABLE)
+ ++tremoloIndex;
+ else
+ tremoloIndex = 0;
+ }
+
+ return count;
+ }
+
+
+ void Chip::WriteBD(Bit8u val)
+ {
+ Bit8u change = regBD ^ val;
+
+ if(!change)
+ return;
+
+ regBD = val;
+ //TODO could do this with shift and xor?
+ vibratoStrength = (val & 0x40) ? 0x00 : 0x01;
+ tremoloStrength = (val & 0x80) ? 0x00 : 0x02;
+
+ if(val & 0x20)
+ {
+ //Drum was just enabled, make sure channel 6 has the right synth
+ if(change & 0x20)
+ {
+ if(opl3Active)
+ chan[6].synthHandler = &Channel::BlockTemplate< sm3Percussion >;
+ else
+ chan[6].synthHandler = &Channel::BlockTemplate< sm2Percussion >;
+ }
+
+ //Bass Drum
+ if(val & 0x10)
+ {
+ chan[6].op[0].KeyOn(0x2);
+ chan[6].op[1].KeyOn(0x2);
+ }
+ else
+ {
+ chan[6].op[0].KeyOff(0x2);
+ chan[6].op[1].KeyOff(0x2);
+ }
+
+ //Hi-Hat
+ if(val & 0x1)
+ chan[7].op[0].KeyOn(0x2);
+ else
+ chan[7].op[0].KeyOff(0x2);
+
+ //Snare
+ if(val & 0x8)
+ chan[7].op[1].KeyOn(0x2);
+ else
+ chan[7].op[1].KeyOff(0x2);
+
+ //Tom-Tom
+ if(val & 0x4)
+ chan[8].op[0].KeyOn(0x2);
+ else
+ chan[8].op[0].KeyOff(0x2);
+
+ //Top Cymbal
+ if(val & 0x2)
+ chan[8].op[1].KeyOn(0x2);
+ else
+ chan[8].op[1].KeyOff(0x2);
+
+ //Toggle keyoffs when we turn off the percussion
+ }
+ else if(change & 0x20)
+ {
+ //Trigger a reset to setup the original synth handler
+ chan[6].ResetC0(this);
+ chan[6].op[0].KeyOff(0x2);
+ chan[6].op[1].KeyOff(0x2);
+ chan[7].op[0].KeyOff(0x2);
+ chan[7].op[1].KeyOff(0x2);
+ chan[8].op[0].KeyOff(0x2);
+ chan[8].op[1].KeyOff(0x2);
+ }
+ }
+
+
+#define REGOP( _FUNC_ ) \
+ index = ( ( reg >> 3) & 0x20 ) | ( reg & 0x1f ); \
+ if ( OpOffsetTable[ index ] ) { \
+ Operator* regOp = (Operator*)( ((char *)this ) + OpOffsetTable[ index ] ); \
+ regOp->_FUNC_( this, val ); \
+ }
+
+#define REGCHAN( _FUNC_ ) \
+ index = ( ( reg >> 4) & 0x10 ) | ( reg & 0xf ); \
+ if ( ChanOffsetTable[ index ] ) { \
+ Channel* regChan = (Channel*)( ((char *)this ) + ChanOffsetTable[ index ] ); \
+ regChan->_FUNC_( this, val ); \
+ }
+
+ void Chip::WriteReg(Bit32u reg, Bit8u val)
+ {
+ Bitu index = 0;
+
+ switch((reg & 0xf0) >> 4)
+ {
+ case 0x00 >> 4:
+ if(reg == 0x01)
+ waveFormMask = (val & 0x20) ? 0x7 : 0x0;
+ else if(reg == 0x104)
+ {
+ //Only detect changes in lowest 6 bits
+ if(!((reg104 ^ val) & 0x3f))
+ return;
+
+ //Always keep the highest bit enabled, for checking > 0x80
+ reg104 = 0x80 | (val & 0x3f);
+ }
+ else if(reg == 0x105)
+ {
+ //MAME says the real opl3 doesn't reset anything on opl3 disable/enable till the next write in another register
+ if(!((opl3Active ^ val) & 1))
+ return;
+
+ opl3Active = (val & 1) ? 0xff : 0;
+
+ //Update the 0xc0 register for all channels to signal the switch to mono/stereo handlers
+ for(int i = 0; i < 18; i++)
+ chan[i].ResetC0(this);
+ }
+ else if(reg == 0x08)
+ reg08 = val;
+
+ case 0x10 >> 4:
+ break;
+
+ case 0x20 >> 4:
+ case 0x30 >> 4:
+ REGOP(Write20);
+ break;
+
+ case 0x40 >> 4:
+ case 0x50 >> 4:
+ REGOP(Write40);
+ break;
+
+ case 0x60 >> 4:
+ case 0x70 >> 4:
+ REGOP(Write60);
+ break;
+
+ case 0x80 >> 4:
+ case 0x90 >> 4:
+ REGOP(Write80);
+ break;
+
+ case 0xa0 >> 4:
+ REGCHAN(WriteA0);
+ break;
+
+ case 0xb0 >> 4:
+ if(reg == 0xbd)
+ WriteBD(val);
+ else
+ REGCHAN(WriteB0);
+
+ break;
+
+ case 0xc0 >> 4:
+ REGCHAN(WriteC0);
+
+ case 0xd0 >> 4:
+ break;
+
+ case 0xe0 >> 4:
+ case 0xf0 >> 4:
+ REGOP(WriteE0);
+ break;
+ }
+ }
+
+
+ Bit32u Chip::WriteAddr(Bit32u port, Bit8u val)
+ {
+ switch(port & 3)
+ {
+ case 0:
+ return val;
+
+ case 2:
+ if(opl3Active || (val == 0x05))
+ return 0x100 | val;
+ else
+ return val;
+ }
+
+ return 0;
+ }
+
+ void Chip::GenerateBlock2(Bitu total, Bit32s *output)
+ {
+ while(total > 0)
+ {
+ Bit32u samples = ForwardLFO(total);
+ memset(output, 0, sizeof(Bit32s) * samples);
+ int count = 0;
+
+ for(Channel *ch = chan; ch < chan + 9;)
+ {
+ count++;
+ ch = (ch->*(ch->synthHandler))(this, samples, output);
+ }
+
+ total -= samples;
+ output += samples;
+ }
+ }
+
+ void Chip::GenerateBlock3(Bitu total, Bit32s *output)
+ {
+ while(total > 0)
+ {
+ Bit32u samples = ForwardLFO((Bit32u)total);
+ memset(output, 0, sizeof(Bit32s) * samples * 2);
+ int count = 0;
+
+ for(Channel *ch = chan; ch < chan + 18;)
+ {
+ count++;
+ ch = (ch->*(ch->synthHandler))(this, samples, output);
+ }
+
+ total -= samples;
+ output += samples * 2;
+ }
+ }
+
+ void Chip::GenerateBlock2_Mix(Bitu total, Bit32s *output)
+ {
+ while(total > 0)
+ {
+ Bit32u samples = ForwardLFO((Bit32u)total);
+ int count = 0;
+ for(Channel *ch = chan; ch < chan + 9;)
+ {
+ count++;
+ ch = (ch->*(ch->synthHandler))(this, samples, output);
+ }
+
+ total -= samples;
+ output += samples;
+ }
+ }
+
+ void Chip::GenerateBlock3_Mix(Bitu total, Bit32s *output)
+ {
+ while(total > 0)
+ {
+ Bit32u samples = ForwardLFO(total);
+ int count = 0;
+ for(Channel *ch = chan; ch < chan + 18;)
+ {
+ count++;
+ ch = (ch->*(ch->synthHandler))(this, samples, output);
+ }
+ total -= samples;
+ output += samples * 2;
+ }
+ }
+
+ void Chip::Setup(Bit32u rate)
+ {
+ double original = OPLRATE;
+ // double original = rate;
+ double scale = original / (double)rate;
+ //Noise counter is run at the same precision as general waves
+ noiseAdd = (Bit32u)(0.5 + scale * (1 << LFO_SH));
+ noiseCounter = 0;
+ noiseValue = 1; //Make sure it triggers the noise xor the first time
+ //The low frequency oscillation counter
+ //Every time his overflows vibrato and tremoloindex are increased
+ lfoAdd = (Bit32u)(0.5 + scale * (1 << LFO_SH));
+ lfoCounter = 0;
+ vibratoIndex = 0;
+ tremoloIndex = 0;
+ //With higher octave this gets shifted up
+ //-1 since the freqCreateTable = *2
+ #ifdef WAVE_PRECISION
+ double freqScale = (1 << 7) * scale * (1 << (WAVE_SH - 1 - 10));
+
+ for(int i = 0; i < 16; i++)
+ freqMul[i] = (Bit32u)(0.5 + freqScale * FreqCreateTable[ i ]);
+
+ #else
+ Bit32u freqScale = (Bit32u)(0.5 + scale * (1 << (WAVE_SH - 1 - 10)));
+
+ for(int i = 0; i < 16; i++)
+ freqMul[i] = freqScale * FreqCreateTable[ i ];
+
+ #endif
+
+ //-3 since the real envelope takes 8 steps to reach the single value we supply
+ for(Bit8u i = 0; i < 76; i++)
+ {
+ Bit8u index, shift;
+ EnvelopeSelect(i, index, shift);
+ linearRates[i] = (Bit32u)(scale * (EnvelopeIncreaseTable[ index ] << (RATE_SH + ENV_EXTRA - shift - 3)));
+ }
+
+ if(rate == 48000)
+ {
+ /* BISQWIT ADD: Use precalculated table for this common sample-rate.
+ * Because the actual generation code, below, is MOLASSES SLOW on DOS.
+ */
+ static const Bit32u precalculated_table[62] =
+ {
+ 2152, 2700, 3228, 3712, 4304, 5399, 6456, 7424, 8608, 10799, 12912, 14849, 17216, 21598,
+ 25824, 29698, 34432, 43196, 51650, 59398, 68864, 86392, 103310, 118795, 137746, 172847,
+ 206619, 237693, 275559, 345774, 413238, 475500, 543030, 678787, 814545, 950302, 1086060,
+ 1357575, 1629090, 1900605, 2172120, 2715151, 3258181, 3801211, 4344241, 5430302,
+ 6516362, 7602423, 8688483, 10860604, 13032725, 15204846, 17376967, 21721209, 26065451,
+ 30409693, 34753934, 43442418, 52130902, 60819386, 69507869, 69507869
+ };
+
+ for(Bit8u i = 0; i < 62; i++)
+ attackRates[i] = precalculated_table[i];
+ }
+ else if(rate == 44100)
+ {
+ static const Bit32u precalculated_table[62] =
+ {
+ 2342, 2939, 3513, 4040, 4685, 5877, 7027, 8081, 9369, 11754, 14054, 16162, 18738, 23508,
+ 28108, 32325, 37478, 47018, 56219, 64649, 74965, 94044, 112448, 129292, 149929, 188132,
+ 224945, 258713, 300002, 376263, 449999, 517550, 591053, 738816, 886579, 1034343, 1182106,
+ 1477633, 1773159, 2068686, 2364213, 2955266, 3546319, 4137373, 4728426, 5910533,
+ 7092639, 8274746, 9456853, 11821066, 14185279, 16549492, 18913706, 23642132, 28370559,
+ 33098985, 37827412, 47284265, 56741118, 66197971, 75654824, 75654824
+ };
+
+ for(Bit8u i = 0; i < 62; i++)
+ attackRates[i] = precalculated_table[i];
+ }
+ else if(rate == 22050)
+ {
+ static const Bit32u precalculated_table[62] =
+ {
+ 4685, 5877, 7027, 8081, 9369, 11754, 14054, 16162, 18738, 23508, 28108, 32325, 37478,
+ 47018, 56219, 64649, 74965, 94044, 112448, 129292, 149929, 188132, 224945, 258713, 300002,
+ 376263, 449999, 517550, 591053, 738816, 886579, 1034343, 1182106, 1477633, 1773159,
+ 2068686, 2364213, 2955266, 3546319, 4137373, 4728426, 5910533, 7092639, 8274746,
+ 9456853, 11821066, 14185279, 16549492, 18913706, 23642132, 28370559, 33098985,
+ 37827412, 47284265, 56741118, 66197971, 75654824, 94568530, 113482236, 132395942,
+ 151309648, 151309648
+ };
+
+ for(Bit8u i = 0; i < 62; i++)
+ attackRates[i] = precalculated_table[i];
+ }
+ //Generate the best matching attack rate
+ else for(Bit8u i = 0; i < 62; i++)
+ {
+ Bit8u index, shift;
+ EnvelopeSelect(i, index, shift);
+ //Original amount of samples the attack would take
+ Bit32s original = (Bit32u)((AttackSamplesTable[ index ] << shift) / scale);
+ Bit32s guessAdd = (Bit32u)(scale * (EnvelopeIncreaseTable[ index ] << (RATE_SH - shift - 3)));
+ Bit32s bestAdd = guessAdd;
+ Bit32u bestDiff = 1 << 30;
+
+ for(Bit32u passes = 0; passes < 16; passes ++)
+ {
+ Bit32s volume = ENV_MAX;
+ Bit32s samples = 0;
+ Bit32u count = 0;
+
+ while(volume > 0 && samples < original * 2)
+ {
+ count += guessAdd;
+ Bit32s change = count >> RATE_SH;
+ count &= RATE_MASK;
+
+ if(GCC_UNLIKELY(change)) // less than 1 %
+ volume += (~volume * change) >> 3;
+
+ samples++;
+ }
+
+ Bit32s diff = original - samples;
+ Bit32u lDiff = labs(diff);
+
+ //Init last on first pass
+ if(lDiff < bestDiff)
+ {
+ bestDiff = lDiff;
+ bestAdd = guessAdd;
+
+ if(!bestDiff)
+ break;
+ }
+
+ //Below our target
+ if(diff < 0)
+ {
+ //Better than the last time
+ Bit32s mul = ((original - diff) << 12) / original;
+ guessAdd = ((guessAdd * mul) >> 12);
+ guessAdd++;
+ }
+ else if(diff > 0)
+ {
+ Bit32s mul = ((original - diff) << 12) / original;
+ guessAdd = (guessAdd * mul) >> 12;
+ guessAdd--;
+ }
+ }
+
+ attackRates[i] = bestAdd;
+ }
+
+ /*fprintf(stderr, "attack rate table: ");
+ for ( Bit8u i = 0; i < 62; i++ )
+ fprintf(stderr, ",%u", attackRates[i]);
+ fprintf(stderr, "\n");*/
+
+ for(Bit8u i = 62; i < 76; i++)
+ {
+ //This should provide instant volume maximizing
+ attackRates[i] = 8 << RATE_SH;
+ }
+
+ //Setup the channels with the correct four op flags
+ //Channels are accessed through a table so they appear linear here
+ chan[ 0].fourMask = 0x00 | (1 << 0);
+ chan[ 1].fourMask = 0x80 | (1 << 0);
+ chan[ 2].fourMask = 0x00 | (1 << 1);
+ chan[ 3].fourMask = 0x80 | (1 << 1);
+ chan[ 4].fourMask = 0x00 | (1 << 2);
+ chan[ 5].fourMask = 0x80 | (1 << 2);
+ chan[ 9].fourMask = 0x00 | (1 << 3);
+ chan[10].fourMask = 0x80 | (1 << 3);
+ chan[11].fourMask = 0x00 | (1 << 4);
+ chan[12].fourMask = 0x80 | (1 << 4);
+ chan[13].fourMask = 0x00 | (1 << 5);
+ chan[14].fourMask = 0x80 | (1 << 5);
+ //mark the percussion channels
+ chan[ 6].fourMask = 0x40;
+ chan[ 7].fourMask = 0x40;
+ chan[ 8].fourMask = 0x40;
+ //Clear Everything in opl3 mode
+ WriteReg(0x105, 0x1);
+
+ for(int i = 0; i < 512; i++)
+ {
+ if(i == 0x105)
+ continue;
+
+ WriteReg(i, 0xff);
+ WriteReg(i, 0x0);
+ }
+
+ WriteReg(0x105, 0x0);
+
+ //Clear everything in opl2 mode
+ for(int i = 0; i < 255; i++)
+ {
+ WriteReg(i, 0xff);
+ WriteReg(i, 0x0);
+ }
+ }
+
+ static bool doneTables = false;
+ void InitTables(void)
+ {
+ if(doneTables)
+ return;
+
+ doneTables = true;
+ #if ( DBOPL_WAVE == WAVE_HANDLER ) || ( DBOPL_WAVE == WAVE_TABLELOG )
+
+ //Exponential volume table, same as the real adlib
+ for(int i = 0; i < 256; i++)
+ {
+ //Save them in reverse
+ ExpTable[i] = (int)(0.5 + (pow(2.0, (255 - i) * (1.0 / 256)) - 1) * 1024);
+ ExpTable[i] += 1024; //or remove the -1 oh well :)
+ //Preshift to the left once so the final volume can shift to the right
+ ExpTable[i] *= 2;
+ }
+
+ #endif
+ #if ( DBOPL_WAVE == WAVE_HANDLER )
+
+ //Add 0.5 for the trunc rounding of the integer cast
+ //Do a PI sinetable instead of the original 0.5 PI
+ for(int i = 0; i < 512; i++)
+ SinTable[i] = (Bit16s)(0.5 - log10(sin((i + 0.5) * (PI / 512.0))) / log10(2.0) * 256);
+
+ #endif
+ #if ( DBOPL_WAVE == WAVE_TABLEMUL )
+
+ //Multiplication based tables
+ for(int i = 0; i < 384; i++)
+ {
+ int s = i * 8;
+ //TODO maybe keep some of the precision errors of the original table?
+ double val = (0.5 + (pow(2.0, -1.0 + (255 - s) * (1.0 / 256))) * (1 << MUL_SH));
+ MulTable[i] = (Bit16u)(val);
+ }
+
+ //Sine Wave Base
+ for(int i = 0; i < 512; i++)
+ {
+ WaveTable[ 0x0200 + i ] = (Bit16s)(sin((i + 0.5) * (PI / 512.0)) * 4084);
+ WaveTable[ 0x0000 + i ] = -WaveTable[ 0x200 + i ];
+ }
+
+ //Exponential wave
+ for(int i = 0; i < 256; i++)
+ {
+ WaveTable[ 0x700 + i ] = (Bit16s)(0.5 + (pow(2.0, -1.0 + (255 - i * 8) * (1.0 / 256))) * 4085);
+ WaveTable[ 0x6ff - i ] = -WaveTable[ 0x700 + i ];
+ }
+
+ #endif
+ #if ( DBOPL_WAVE == WAVE_TABLELOG )
+
+ //Sine Wave Base
+ for(int i = 0; i < 512; i++)
+ {
+ WaveTable[ 0x0200 + i ] = (Bit16s)(0.5 - log10(sin((i + 0.5) * (PI / 512.0))) / log10(2.0) * 256);
+ WaveTable[ 0x0000 + i ] = ((Bit16s)0x8000) | WaveTable[ 0x200 + i];
+ }
+
+ //Exponential wave
+ for(int i = 0; i < 256; i++)
+ {
+ WaveTable[ 0x700 + i ] = i * 8;
+ WaveTable[ 0x6ff - i ] = ((Bit16s)0x8000) | i * 8;
+ }
+
+ #endif
+ // | |//\\|____|WAV7|//__|/\ |____|/\/\|
+ // |\\//| | |WAV7| | \/| | |
+ // |06 |0126|27 |7 |3 |4 |4 5 |5 |
+ #if (( DBOPL_WAVE == WAVE_TABLELOG ) || ( DBOPL_WAVE == WAVE_TABLEMUL ))
+
+ for(int i = 0; i < 256; i++)
+ {
+ //Fill silence gaps
+ WaveTable[ 0x400 + i ] = WaveTable[0];
+ WaveTable[ 0x500 + i ] = WaveTable[0];
+ WaveTable[ 0x900 + i ] = WaveTable[0];
+ WaveTable[ 0xc00 + i ] = WaveTable[0];
+ WaveTable[ 0xd00 + i ] = WaveTable[0];
+ //Replicate sines in other pieces
+ WaveTable[ 0x800 + i ] = WaveTable[ 0x200 + i ];
+ //double speed sines
+ WaveTable[ 0xa00 + i ] = WaveTable[ 0x200 + i * 2 ];
+ WaveTable[ 0xb00 + i ] = WaveTable[ 0x000 + i * 2 ];
+ WaveTable[ 0xe00 + i ] = WaveTable[ 0x200 + i * 2 ];
+ WaveTable[ 0xf00 + i ] = WaveTable[ 0x200 + i * 2 ];
+ }
+
+ #endif
+
+ //Create the ksl table
+ for(int oct = 0; oct < 8; oct++)
+ {
+ int base = oct * 8;
+
+ for(int i = 0; i < 16; i++)
+ {
+ int val = base - KslCreateTable[i];
+
+ if(val < 0)
+ val = 0;
+
+ //*4 for the final range to match attenuation range
+ KslTable[ oct * 16 + i ] = val * 4;
+ }
+ }
+
+ //Create the Tremolo table, just increase and decrease a triangle wave
+ for(Bit8u i = 0; i < TREMOLO_TABLE / 2; i++)
+ {
+ Bit8u val = i << ENV_EXTRA;
+ TremoloTable[i] = val;
+ TremoloTable[TREMOLO_TABLE - 1 - i] = val;
+ }
+
+ //Create a table with offsets of the channels from the start of the chip
+ DBOPL::Chip *chip = 0;
+
+ for(Bitu i = 0; i < 32; i++)
+ {
+ Bitu index = i & 0xf;
+
+ if(index >= 9)
+ {
+ ChanOffsetTable[i] = 0;
+ continue;
+ }
+
+ //Make sure the four op channels follow eachother
+ if(index < 6)
+ index = (index % 3) * 2 + (index / 3);
+
+ //Add back the bits for highest ones
+ if(i >= 16)
+ index += 9;
+
+ Bitu blah = reinterpret_cast<Bitu>(&(chip->chan[ index ]));
+ ChanOffsetTable[i] = blah;
+ }
+
+ //Same for operators
+ for(Bitu i = 0; i < 64; i++)
+ {
+ if(i % 8 >= 6 || ((i / 8) % 4 == 3))
+ {
+ OpOffsetTable[i] = 0;
+ continue;
+ }
+
+ Bitu chNum = (i / 8) * 3 + (i % 8) % 3;
+
+ //Make sure we use 16 and up for the 2nd range to match the chanoffset gap
+ if(chNum >= 12)
+ chNum += 16 - 12;
+
+ Bitu opNum = (i % 8) / 3;
+ DBOPL::Channel *chan = 0;
+ Bitu blah = reinterpret_cast<Bitu>(&(chan->op[opNum]));
+ OpOffsetTable[i] = ChanOffsetTable[ chNum ] + blah;
+ }
+
+ #if 0
+
+ //Stupid checks if table's are correct
+ for(Bitu i = 0; i < 18; i++)
+ {
+ Bit32u find = (Bit16u)(&(chip->chan[ i ]));
+
+ for(Bitu c = 0; c < 32; c++)
+ {
+ if(ChanOffsetTable[c] == find)
+ {
+ find = 0;
+ break;
+ }
+ }
+
+ if(find)
+ find = find;
+ }
+
+ for(Bitu i = 0; i < 36; i++)
+ {
+ Bit32u find = (Bit16u)(&(chip->chan[ i / 2 ].op[i % 2]));
+
+ for(Bitu c = 0; c < 64; c++)
+ {
+ if(OpOffsetTable[c] == find)
+ {
+ find = 0;
+ break;
+ }
+ }
+
+ if(find)
+ find = find;
+ }
+
+ #endif
+ }
+
+ Bit32u Handler::WriteAddr(Bit32u port, Bit8u val)
+ {
+ return chip.WriteAddr(port, val);
+ }
+ void Handler::WriteReg(Bit32u addr, Bit8u val)
+ {
+ chip.WriteReg(addr, val);
+ }
+
+ void Handler::Generate(void(*AddSamples_m32)(Bitu, Bit32s *),
+ void(*AddSamples_s32)(Bitu, Bit32s *),
+ Bitu samples)
+ {
+ Bit32s buffer[ 512 * 2 ];
+
+ if(GCC_UNLIKELY(samples > 512))
+ samples = 512;
+
+ if(!chip.opl3Active)
+ {
+ chip.GenerateBlock2(samples, buffer);
+ AddSamples_m32(samples, buffer);
+ }
+ else
+ {
+ chip.GenerateBlock3(samples, buffer);
+ AddSamples_s32(samples, buffer);
+ }
+ }
+
+ void Handler::GenerateArr(Bit32s *out, Bitu *samples)
+ {
+ if(GCC_UNLIKELY(*samples > 512))
+ *samples = 512;
+
+ if(!chip.opl3Active)
+ chip.GenerateBlock2(*samples, out);
+ else
+ chip.GenerateBlock3(*samples, out);
+ }
+
+ void Handler::GenerateArr(Bit32s *out, ssize_t *samples)
+ {
+ if(GCC_UNLIKELY(*samples > 512))
+ *samples = 512;
+
+ if(!chip.opl3Active)
+ chip.GenerateBlock2(static_cast<Bitu>(*samples), out);
+ else
+ chip.GenerateBlock3(static_cast<Bitu>(*samples), out);
+ }
+
+ void Handler::GenerateArr(Bit16s *out, ssize_t *samples)
+ {
+ Bit32s out32[1024];
+ if(GCC_UNLIKELY(*samples > 512))
+ *samples = 512;
+ memset(out32, 0, sizeof(Bit32s) * 1024);
+ if(!chip.opl3Active)
+ chip.GenerateBlock2(static_cast<Bitu>(*samples), out32);
+ else
+ chip.GenerateBlock3(static_cast<Bitu>(*samples), out32);
+ ssize_t sz = *samples * 2;
+ for(ssize_t i = 0; i < sz; i++)
+ out[i] = static_cast<Bit16s>(DBOPL_CLAMP(out32[i], static_cast<ssize_t>(INT16_MIN), static_cast<ssize_t>(INT16_MAX)));
+ }
+
+ void Handler::GenerateArrMix(Bit32s *out, ssize_t *samples)
+ {
+ if(GCC_UNLIKELY(*samples > 512))
+ *samples = 512;
+ if(!chip.opl3Active)
+ chip.GenerateBlock2_Mix(static_cast<Bitu>(*samples), out);
+ else
+ chip.GenerateBlock3_Mix(static_cast<Bitu>(*samples), out);
+ }
+
+ void Handler::GenerateArrMix(Bit16s *out, ssize_t *samples)
+ {
+ Bit32s out32[1024];
+ if(GCC_UNLIKELY(*samples > 512))
+ *samples = 512;
+ memset(out32, 0, sizeof(Bit32s) * 1024);
+ if(!chip.opl3Active)
+ chip.GenerateBlock2(static_cast<Bitu>(*samples), out32);
+ else
+ chip.GenerateBlock3(static_cast<Bitu>(*samples), out32);
+ ssize_t sz = *samples * 2;
+ for(ssize_t i = 0; i < sz; i++)
+ out[i] += static_cast<Bit16s>(DBOPL_CLAMP(out32[i], static_cast<ssize_t>(INT16_MIN), static_cast<ssize_t>(INT16_MAX)));
+ }
+
+
+ void Handler::Init(Bitu rate)
+ {
+ InitTables();
+ chip.Setup((Bit32u)rate);
+ }
+
+
+} //Namespace DBOPL
+
+//#endif //ADLMIDI_USE_DOSBOX_OPL
diff --git a/src/chips/dosbox/dbopl.h b/src/chips/dosbox/dbopl.h
new file mode 100644
index 0000000..b5b2ba1
--- /dev/null
+++ b/src/chips/dosbox/dbopl.h
@@ -0,0 +1,314 @@
+/*
+ * Copyright (C) 2002-2010 The DOSBox Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+
+/* BEGIN MIDIPLAY GLUE */
+#include <stdint.h>
+#include <stdlib.h>
+typedef unsigned long Bitu;
+typedef signed long Bits;
+typedef unsigned Bit32u;
+typedef int Bit32s;
+typedef unsigned short Bit16u;
+typedef signed short Bit16s;
+typedef unsigned char Bit8u;
+typedef signed char Bit8s;
+#define INLINE inline
+#ifdef _MSC_VER
+#define GCC_UNLIKELY(x) (!!(x) == 0)
+#define GCC_LIKELY(x) (!!(x) == 1)
+#else
+#define GCC_UNLIKELY(x) __builtin_expect((x),0)
+#define GCC_LIKELY(x) __builtin_expect((x),1)
+#endif
+/* END MIDIPLAY GLUE */
+
+//Use 8 handlers based on a small logatirmic wavetabe and an exponential table for volume
+#define WAVE_HANDLER 10
+//Use a logarithmic wavetable with an exponential table for volume
+#define WAVE_TABLELOG 11
+//Use a linear wavetable with a multiply table for volume
+#define WAVE_TABLEMUL 12
+
+//Select the type of wave generator routine
+#define DBOPL_WAVE WAVE_TABLEMUL
+
+#ifdef _WIN32
+# ifdef _MSC_VER
+# ifdef _WIN64
+typedef __int64 ssize_t;
+# else
+typedef __int32 ssize_t;
+# endif
+# else
+# ifdef _WIN64
+typedef int64_t ssize_t;
+# else
+typedef int32_t ssize_t;
+# endif
+# endif
+#endif
+
+namespace DBOPL
+{
+
+ struct Chip;
+ struct Operator;
+ struct Channel;
+
+#if (DBOPL_WAVE == WAVE_HANDLER)
+ typedef Bits(DB_FASTCALL *WaveHandler)(Bitu i, Bitu volume);
+#endif
+
+ typedef Bits(DBOPL::Operator::*VolumeHandler)();
+ typedef Channel *(DBOPL::Channel::*SynthHandler)(Chip *chip, Bit32u samples, Bit32s *output);
+
+ //Different synth modes that can generate blocks of data
+ typedef enum
+ {
+ sm2AM,
+ sm2FM,
+ sm3AM,
+ sm3FM,
+ sm4Start,
+ sm3FMFM,
+ sm3AMFM,
+ sm3FMAM,
+ sm3AMAM,
+ sm6Start,
+ sm2Percussion,
+ sm3Percussion
+ } SynthMode;
+
+ //Shifts for the values contained in chandata variable
+ enum
+ {
+ SHIFT_KSLBASE = 16,
+ SHIFT_KEYCODE = 24
+ };
+
+ struct Operator
+ {
+ public:
+ //Masks for operator 20 values
+ enum
+ {
+ MASK_KSR = 0x10,
+ MASK_SUSTAIN = 0x20,
+ MASK_VIBRATO = 0x40,
+ MASK_TREMOLO = 0x80
+ };
+
+ typedef enum
+ {
+ OFF,
+ RELEASE,
+ SUSTAIN,
+ DECAY,
+ ATTACK
+ } State;
+
+ VolumeHandler volHandler;
+
+#if (DBOPL_WAVE == WAVE_HANDLER)
+ WaveHandler waveHandler; //Routine that generate a wave
+#else
+ Bit16s *waveBase;
+ Bit32u waveMask;
+ Bit32u waveStart;
+#endif
+ Bit32u waveIndex; //WAVE_BITS shifted counter of the frequency index
+ Bit32u waveAdd; //The base frequency without vibrato
+ Bit32u waveCurrent; //waveAdd + vibratao
+
+ Bit32u chanData; //Frequency/octave and derived data coming from whatever channel controls this
+ Bit32u freqMul; //Scale channel frequency with this, TODO maybe remove?
+ Bit32u vibrato; //Scaled up vibrato strength
+ Bit32s sustainLevel; //When stopping at sustain level stop here
+ Bit32s totalLevel; //totalLevel is added to every generated volume
+ Bit32u currentLevel; //totalLevel + tremolo
+ Bit32s volume; //The currently active volume
+
+ Bit32u attackAdd; //Timers for the different states of the envelope
+ Bit32u decayAdd;
+ Bit32u releaseAdd;
+ Bit32u rateIndex; //Current position of the evenlope
+
+ Bit8u rateZero; //Bits for the different states of the envelope having no changes
+ Bit8u keyOn; //Bitmask of different values that can generate keyon
+ //Registers, also used to check for changes
+ Bit8u reg20, reg40, reg60, reg80, regE0;
+ //Active part of the envelope we're in
+ Bit8u state;
+ //0xff when tremolo is enabled
+ Bit8u tremoloMask;
+ //Strength of the vibrato
+ Bit8u vibStrength;
+ //Keep track of the calculated KSR so we can check for changes
+ Bit8u ksr;
+ private:
+ void SetState(Bit8u s);
+ void UpdateAttack(const Chip *chip);
+ void UpdateRelease(const Chip *chip);
+ void UpdateDecay(const Chip *chip);
+ public:
+ void UpdateAttenuation();
+ void UpdateRates(const Chip *chip);
+ void UpdateFrequency();
+
+ void Write20(const Chip *chip, Bit8u val);
+ void Write40(const Chip *chip, Bit8u val);
+ void Write60(const Chip *chip, Bit8u val);
+ void Write80(const Chip *chip, Bit8u val);
+ void WriteE0(const Chip *chip, Bit8u val);
+
+ bool Silent() const;
+ void Prepare(const Chip *chip);
+
+ void KeyOn(Bit8u mask);
+ void KeyOff(Bit8u mask);
+
+ template< State state>
+ Bits TemplateVolume();
+
+ Bit32s RateForward(Bit32u add);
+ Bitu ForwardWave();
+ Bitu ForwardVolume();
+
+ Bits GetSample(Bits modulation);
+ Bits GetWave(Bitu index, Bitu vol);
+ public:
+ Operator();
+ char ____padding[5];
+ };
+
+ struct Channel
+ {
+ Operator op[2];
+ inline Operator *Op(Bitu index)
+ {
+ return &((this + (index >> 1))->op[ index & 1 ]);
+ }
+ SynthHandler synthHandler;
+ Bit32u chanData; //Frequency/octave and derived values
+ Bit32s old[2]; //Old data for feedback
+
+ Bit8u feedback; //Feedback shift
+ Bit8u regB0; //Register values to check for changes
+ Bit8u regC0;
+ //This should correspond with reg104, bit 6 indicates a Percussion channel, bit 7 indicates a silent channel
+ Bit8u fourMask;
+ Bit8s maskLeft; //Sign extended values for both channel's panning
+ Bit8s maskRight;
+
+ //Forward the channel data to the operators of the channel
+ void SetChanData(const Chip *chip, Bit32u data);
+ //Change in the chandata, check for new values and if we have to forward to operators
+ void UpdateFrequency(const Chip *chip, Bit8u fourOp);
+ void WriteA0(const Chip *chip, Bit8u val);
+ void WriteB0(const Chip *chip, Bit8u val);
+ void WriteC0(const Chip *chip, Bit8u val);
+ void ResetC0(const Chip *chip);
+
+ //call this for the first channel
+ template< bool opl3Mode >
+ void GeneratePercussion(Chip *chip, Bit32s *output);
+
+ //Generate blocks of data in specific modes
+ template<SynthMode mode>
+ Channel *BlockTemplate(Chip *chip, Bit32u samples, Bit32s *output);
+ Channel();
+ char ____padding[6];
+ };
+
+ struct Chip
+ {
+ //This is used as the base counter for vibrato and tremolo
+ Bit32u lfoCounter;
+ Bit32u lfoAdd;
+
+
+ Bit32u noiseCounter;
+ Bit32u noiseAdd;
+ Bit32u noiseValue;
+
+ //Frequency scales for the different multiplications
+ Bit32u freqMul[16];
+ //Rates for decay and release for rate of this chip
+ Bit32u linearRates[76];
+ //Best match attack rates for the rate of this chip
+ Bit32u attackRates[76];
+
+ //18 channels with 2 operators each
+ Channel chan[18];
+
+ Bit8u reg104;
+ Bit8u reg08;
+ Bit8u reg04;
+ Bit8u regBD;
+ Bit8u vibratoIndex;
+ Bit8u tremoloIndex;
+ Bit8s vibratoSign;
+ Bit8u vibratoShift;
+ Bit8u tremoloValue;
+ Bit8u vibratoStrength;
+ Bit8u tremoloStrength;
+ //Mask for allowed wave forms
+ Bit8u waveFormMask;
+ //0 or -1 when enabled
+ Bit8s opl3Active;
+
+ //Return the maximum amount of samples before and LFO change
+ Bit32u ForwardLFO(Bit32u samples);
+ Bit32u ForwardNoise();
+
+ void WriteBD(Bit8u val);
+ void WriteReg(Bit32u reg, Bit8u val);
+
+ Bit32u WriteAddr(Bit32u port, Bit8u val);
+
+ void GenerateBlock2(Bitu samples, Bit32s *output);
+ void GenerateBlock3(Bitu samples, Bit32s *output);
+
+ void GenerateBlock2_Mix(Bitu samples, Bit32s *output);
+ void GenerateBlock3_Mix(Bitu samples, Bit32s *output);
+
+ void Generate(Bit32u samples);
+ void Setup(Bit32u r);
+
+ Chip();
+ };
+
+ struct Handler
+ {
+ DBOPL::Chip chip;
+ Bit32u WriteAddr(Bit32u port, Bit8u val);
+ void WriteReg(Bit32u addr, Bit8u val);
+ void Generate(void(*AddSamples_m32)(Bitu, Bit32s *),
+ void(*AddSamples_s32)(Bitu, Bit32s *),
+ Bitu samples);
+ void GenerateArr(Bit32s *out, Bitu *samples);
+ void GenerateArr(Bit32s *out, ssize_t *samples);
+ void GenerateArr(Bit16s *out, ssize_t *samples);
+ void GenerateArrMix(Bit32s *out, ssize_t *samples);
+ void GenerateArrMix(Bit16s *out, ssize_t *samples);
+ void Init(Bitu rate);
+ };
+
+
+} //Namespace
diff --git a/src/chips/dosbox_opl3.cpp b/src/chips/dosbox_opl3.cpp
new file mode 100644
index 0000000..b696343
--- /dev/null
+++ b/src/chips/dosbox_opl3.cpp
@@ -0,0 +1,84 @@
+#include "dosbox_opl3.h"
+#include "dosbox/dbopl.h"
+#include <cstdlib>
+#include <assert.h>
+
+DosBoxOPL3::DosBoxOPL3() :
+ OPLChipBase(),
+ m_chip(nullptr)
+{
+ reset();
+}
+
+DosBoxOPL3::DosBoxOPL3(const DosBoxOPL3 &c) :
+ OPLChipBase(c),
+ m_chip(nullptr)
+{
+ setRate(c.m_rate);
+}
+
+DosBoxOPL3::~DosBoxOPL3()
+{
+ DBOPL::Handler *chip_r = reinterpret_cast<DBOPL::Handler*>(m_chip);
+ delete chip_r;
+}
+
+void DosBoxOPL3::setRate(uint32_t rate)
+{
+ OPLChipBase::setRate(rate);
+ reset();
+}
+
+void DosBoxOPL3::reset()
+{
+ DBOPL::Handler *chip_r = reinterpret_cast<DBOPL::Handler*>(m_chip);
+ if(m_chip && chip_r)
+ delete chip_r;
+ m_chip = new DBOPL::Handler;
+ chip_r = reinterpret_cast<DBOPL::Handler*>(m_chip);
+ chip_r->Init(m_rate);
+}
+
+void DosBoxOPL3::reset(uint32_t rate)
+{
+ setRate(rate);
+}
+
+void DosBoxOPL3::writeReg(uint16_t addr, uint8_t data)
+{
+ DBOPL::Handler *chip_r = reinterpret_cast<DBOPL::Handler*>(m_chip);
+ chip_r->WriteReg(static_cast<Bit32u>(addr), data);
+}
+
+int DosBoxOPL3::generate(int16_t *output, size_t frames)
+{
+ DBOPL::Handler *chip_r = reinterpret_cast<DBOPL::Handler*>(m_chip);
+ ssize_t left = (ssize_t)frames;
+ while(left > 0)
+ {
+ ssize_t frames_i = left;
+ chip_r->GenerateArr(output, &frames_i);
+ output += (frames_i * 2);
+ left -= frames_i;
+ }
+ return (int)frames;
+}
+
+int DosBoxOPL3::generateAndMix(int16_t *output, size_t frames)
+{
+ DBOPL::Handler *chip_r = reinterpret_cast<DBOPL::Handler*>(m_chip);
+ ssize_t left = (ssize_t)frames;
+ while(left > 0)
+ {
+ ssize_t frames_i = left;
+ chip_r->GenerateArrMix(output, &frames_i);
+ output += (frames_i * 2);
+ left -= frames_i;
+ }
+ return (int)frames;
+}
+
+const char *DosBoxOPL3::emulatorName()
+{
+ return "DosBox 0.74 OPL3";
+}
diff --git a/src/chips/dosbox_opl3.h b/src/chips/dosbox_opl3.h
new file mode 100644
index 0000000..46c20fa
--- /dev/null
+++ b/src/chips/dosbox_opl3.h
@@ -0,0 +1,23 @@
+#ifndef DOSBOX_OPL3_H
+#define DOSBOX_OPL3_H
+
+#include "opl_chip_base.h"
+
+class DosBoxOPL3 final : public OPLChipBase
+{
+ void *m_chip;
+public:
+ DosBoxOPL3();
+ DosBoxOPL3(const DosBoxOPL3 &c);
+ virtual ~DosBoxOPL3() override;
+
+ virtual void setRate(uint32_t rate) override;
+ virtual void reset() override;
+ virtual void reset(uint32_t rate) override;
+ virtual void writeReg(uint16_t addr, uint8_t data) override;
+ virtual int generate(int16_t *output, size_t frames) override;
+ virtual int generateAndMix(int16_t *output, size_t frames) override;
+ virtual const char *emulatorName() override;
+};
+
+#endif // DOSBOX_OPL3_H
diff --git a/src/chips/nuked/nukedopl3.c b/src/chips/nuked/nukedopl3.c
new file mode 100644
index 0000000..eadb6b9
--- /dev/null
+++ b/src/chips/nuked/nukedopl3.c
@@ -0,0 +1,1391 @@
+/*
+ * Copyright (C) 2013-2018 Alexey Khokholov (Nuke.YKT)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ *
+ * Nuked OPL3 emulator.
+ * Thanks:
+ * MAME Development Team(Jarek Burczynski, Tatsuyuki Satoh):
+ * Feedback and Rhythm part calculation information.
+ * forums.submarine.org.uk(carbon14, opl3):
+ * Tremolo and phase generator calculation information.
+ * OPLx decapsulated(Matthew Gambrell, Olli Niemitalo):
+ * OPL2 ROMs.
+ * siliconpr0n.org(John McMaster, digshadow):
+ * YMF262 and VRC VII decaps and die shots.
+ *
+ * version: 1.8
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "nukedopl3.h"
+
+#define RSM_FRAC 10
+
+/* Channel types */
+
+enum {
+ ch_2op = 0,
+ ch_4op = 1,
+ ch_4op2 = 2,
+ ch_drum = 3
+};
+
+/* Envelope key types */
+
+enum {
+ egk_norm = 0x01,
+ egk_drum = 0x02
+};
+
+
+/*
+ * logsin table
+ */
+
+static const Bit16u logsinrom[256] = {
+ 0x859, 0x6c3, 0x607, 0x58b, 0x52e, 0x4e4, 0x4a6, 0x471,
+ 0x443, 0x41a, 0x3f5, 0x3d3, 0x3b5, 0x398, 0x37e, 0x365,
+ 0x34e, 0x339, 0x324, 0x311, 0x2ff, 0x2ed, 0x2dc, 0x2cd,
+ 0x2bd, 0x2af, 0x2a0, 0x293, 0x286, 0x279, 0x26d, 0x261,
+ 0x256, 0x24b, 0x240, 0x236, 0x22c, 0x222, 0x218, 0x20f,
+ 0x206, 0x1fd, 0x1f5, 0x1ec, 0x1e4, 0x1dc, 0x1d4, 0x1cd,
+ 0x1c5, 0x1be, 0x1b7, 0x1b0, 0x1a9, 0x1a2, 0x19b, 0x195,
+ 0x18f, 0x188, 0x182, 0x17c, 0x177, 0x171, 0x16b, 0x166,
+ 0x160, 0x15b, 0x155, 0x150, 0x14b, 0x146, 0x141, 0x13c,
+ 0x137, 0x133, 0x12e, 0x129, 0x125, 0x121, 0x11c, 0x118,
+ 0x114, 0x10f, 0x10b, 0x107, 0x103, 0x0ff, 0x0fb, 0x0f8,
+ 0x0f4, 0x0f0, 0x0ec, 0x0e9, 0x0e5, 0x0e2, 0x0de, 0x0db,
+ 0x0d7, 0x0d4, 0x0d1, 0x0cd, 0x0ca, 0x0c7, 0x0c4, 0x0c1,
+ 0x0be, 0x0bb, 0x0b8, 0x0b5, 0x0b2, 0x0af, 0x0ac, 0x0a9,
+ 0x0a7, 0x0a4, 0x0a1, 0x09f, 0x09c, 0x099, 0x097, 0x094,
+ 0x092, 0x08f, 0x08d, 0x08a, 0x088, 0x086, 0x083, 0x081,
+ 0x07f, 0x07d, 0x07a, 0x078, 0x076, 0x074, 0x072, 0x070,
+ 0x06e, 0x06c, 0x06a, 0x068, 0x066, 0x064, 0x062, 0x060,
+ 0x05e, 0x05c, 0x05b, 0x059, 0x057, 0x055, 0x053, 0x052,
+ 0x050, 0x04e, 0x04d, 0x04b, 0x04a, 0x048, 0x046, 0x045,
+ 0x043, 0x042, 0x040, 0x03f, 0x03e, 0x03c, 0x03b, 0x039,
+ 0x038, 0x037, 0x035, 0x034, 0x033, 0x031, 0x030, 0x02f,
+ 0x02e, 0x02d, 0x02b, 0x02a, 0x029, 0x028, 0x027, 0x026,
+ 0x025, 0x024, 0x023, 0x022, 0x021, 0x020, 0x01f, 0x01e,
+ 0x01d, 0x01c, 0x01b, 0x01a, 0x019, 0x018, 0x017, 0x017,
+ 0x016, 0x015, 0x014, 0x014, 0x013, 0x012, 0x011, 0x011,
+ 0x010, 0x00f, 0x00f, 0x00e, 0x00d, 0x00d, 0x00c, 0x00c,
+ 0x00b, 0x00a, 0x00a, 0x009, 0x009, 0x008, 0x008, 0x007,
+ 0x007, 0x007, 0x006, 0x006, 0x005, 0x005, 0x005, 0x004,
+ 0x004, 0x004, 0x003, 0x003, 0x003, 0x002, 0x002, 0x002,
+ 0x002, 0x001, 0x001, 0x001, 0x001, 0x001, 0x001, 0x001,
+ 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000
+};
+
+/*
+ * exp table
+ */
+
+static const Bit16u exprom[256] = {
+ 0x7fa, 0x7f5, 0x7ef, 0x7ea, 0x7e4, 0x7df, 0x7da, 0x7d4,
+ 0x7cf, 0x7c9, 0x7c4, 0x7bf, 0x7b9, 0x7b4, 0x7ae, 0x7a9,
+ 0x7a4, 0x79f, 0x799, 0x794, 0x78f, 0x78a, 0x784, 0x77f,
+ 0x77a, 0x775, 0x770, 0x76a, 0x765, 0x760, 0x75b, 0x756,
+ 0x751, 0x74c, 0x747, 0x742, 0x73d, 0x738, 0x733, 0x72e,
+ 0x729, 0x724, 0x71f, 0x71a, 0x715, 0x710, 0x70b, 0x706,
+ 0x702, 0x6fd, 0x6f8, 0x6f3, 0x6ee, 0x6e9, 0x6e5, 0x6e0,
+ 0x6db, 0x6d6, 0x6d2, 0x6cd, 0x6c8, 0x6c4, 0x6bf, 0x6ba,
+ 0x6b5, 0x6b1, 0x6ac, 0x6a8, 0x6a3, 0x69e, 0x69a, 0x695,
+ 0x691, 0x68c, 0x688, 0x683, 0x67f, 0x67a, 0x676, 0x671,
+ 0x66d, 0x668, 0x664, 0x65f, 0x65b, 0x657, 0x652, 0x64e,
+ 0x649, 0x645, 0x641, 0x63c, 0x638, 0x634, 0x630, 0x62b,
+ 0x627, 0x623, 0x61e, 0x61a, 0x616, 0x612, 0x60e, 0x609,
+ 0x605, 0x601, 0x5fd, 0x5f9, 0x5f5, 0x5f0, 0x5ec, 0x5e8,
+ 0x5e4, 0x5e0, 0x5dc, 0x5d8, 0x5d4, 0x5d0, 0x5cc, 0x5c8,
+ 0x5c4, 0x5c0, 0x5bc, 0x5b8, 0x5b4, 0x5b0, 0x5ac, 0x5a8,
+ 0x5a4, 0x5a0, 0x59c, 0x599, 0x595, 0x591, 0x58d, 0x589,
+ 0x585, 0x581, 0x57e, 0x57a, 0x576, 0x572, 0x56f, 0x56b,
+ 0x567, 0x563, 0x560, 0x55c, 0x558, 0x554, 0x551, 0x54d,
+ 0x549, 0x546, 0x542, 0x53e, 0x53b, 0x537, 0x534, 0x530,
+ 0x52c, 0x529, 0x525, 0x522, 0x51e, 0x51b, 0x517, 0x514,
+ 0x510, 0x50c, 0x509, 0x506, 0x502, 0x4ff, 0x4fb, 0x4f8,
+ 0x4f4, 0x4f1, 0x4ed, 0x4ea, 0x4e7, 0x4e3, 0x4e0, 0x4dc,
+ 0x4d9, 0x4d6, 0x4d2, 0x4cf, 0x4cc, 0x4c8, 0x4c5, 0x4c2,
+ 0x4be, 0x4bb, 0x4b8, 0x4b5, 0x4b1, 0x4ae, 0x4ab, 0x4a8,
+ 0x4a4, 0x4a1, 0x49e, 0x49b, 0x498, 0x494, 0x491, 0x48e,
+ 0x48b, 0x488, 0x485, 0x482, 0x47e, 0x47b, 0x478, 0x475,
+ 0x472, 0x46f, 0x46c, 0x469, 0x466, 0x463, 0x460, 0x45d,
+ 0x45a, 0x457, 0x454, 0x451, 0x44e, 0x44b, 0x448, 0x445,
+ 0x442, 0x43f, 0x43c, 0x439, 0x436, 0x433, 0x430, 0x42d,
+ 0x42a, 0x428, 0x425, 0x422, 0x41f, 0x41c, 0x419, 0x416,
+ 0x414, 0x411, 0x40e, 0x40b, 0x408, 0x406, 0x403, 0x400
+};
+
+/*
+ * freq mult table multiplied by 2
+ *
+ * 1/2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 12, 12, 15, 15
+ */
+
+static const Bit8u mt[16] = {
+ 1, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 20, 24, 24, 30, 30
+};
+
+/*
+ * ksl table
+ */
+
+static const Bit8u kslrom[16] = {
+ 0, 32, 40, 45, 48, 51, 53, 55, 56, 58, 59, 60, 61, 62, 63, 64
+};
+
+static const Bit8u kslshift[4] = {
+ 8, 1, 2, 0
+};
+
+/*
+ * envelope generator constants
+ */
+
+static const Bit8u eg_incstep[4][4] = {
+ { 0, 0, 0, 0 },
+ { 1, 0, 0, 0 },
+ { 1, 0, 1, 0 },
+ { 1, 1, 1, 0 }
+};
+
+/*
+ * address decoding
+ */
+
+static const Bit8s ad_slot[0x20] = {
+ 0, 1, 2, 3, 4, 5, -1, -1, 6, 7, 8, 9, 10, 11, -1, -1,
+ 12, 13, 14, 15, 16, 17, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+};
+
+static const Bit8u ch_slot[18] = {
+ 0, 1, 2, 6, 7, 8, 12, 13, 14, 18, 19, 20, 24, 25, 26, 30, 31, 32
+};
+
+/*
+ * Envelope generator
+ */
+
+typedef Bit16s(*envelope_sinfunc)(Bit16u phase, Bit16u envelope);
+typedef void(*envelope_genfunc)(opl3_slot *slott);
+
+static Bit16s OPL3_EnvelopeCalcExp(Bit32u level)
+{
+ if (level > 0x1fff)
+ {
+ level = 0x1fff;
+ }
+ return (exprom[level & 0xff] << 1) >> (level >> 8);
+}
+
+static Bit16s OPL3_EnvelopeCalcSin0(Bit16u phase, Bit16u envelope)
+{
+ Bit16u out = 0;
+ Bit16u neg = 0;
+ phase &= 0x3ff;
+ if (phase & 0x200)
+ {
+ neg = 0xffff;
+ }
+ if (phase & 0x100)
+ {
+ out = logsinrom[(phase & 0xff) ^ 0xff];
+ }
+ else
+ {
+ out = logsinrom[phase & 0xff];
+ }
+ return OPL3_EnvelopeCalcExp(out + (envelope << 3)) ^ neg;
+}
+
+static Bit16s OPL3_EnvelopeCalcSin1(Bit16u phase, Bit16u envelope)
+{
+ Bit16u out = 0;
+ phase &= 0x3ff;
+ if (phase & 0x200)
+ {
+ out = 0x1000;
+ }
+ else if (phase & 0x100)
+ {
+ out = logsinrom[(phase & 0xff) ^ 0xff];
+ }
+ else
+ {
+ out = logsinrom[phase & 0xff];
+ }
+ return OPL3_EnvelopeCalcExp(out + (envelope << 3));
+}
+
+static Bit16s OPL3_EnvelopeCalcSin2(Bit16u phase, Bit16u envelope)
+{
+ Bit16u out = 0;
+ phase &= 0x3ff;
+ if (phase & 0x100)
+ {
+ out = logsinrom[(phase & 0xff) ^ 0xff];
+ }
+ else
+ {
+ out = logsinrom[phase & 0xff];
+ }
+ return OPL3_EnvelopeCalcExp(out + (envelope << 3));
+}
+
+static Bit16s OPL3_EnvelopeCalcSin3(Bit16u phase, Bit16u envelope)
+{
+ Bit16u out = 0;
+ phase &= 0x3ff;
+ if (phase & 0x100)
+ {
+ out = 0x1000;
+ }
+ else
+ {
+ out = logsinrom[phase & 0xff];
+ }
+ return OPL3_EnvelopeCalcExp(out + (envelope << 3));
+}
+
+static Bit16s OPL3_EnvelopeCalcSin4(Bit16u phase, Bit16u envelope)
+{
+ Bit16u out = 0;
+ Bit16u neg = 0;
+ phase &= 0x3ff;
+ if ((phase & 0x300) == 0x100)
+ {
+ neg = 0xffff;
+ }
+ if (phase & 0x200)
+ {
+ out = 0x1000;
+ }
+ else if (phase & 0x80)
+ {
+ out = logsinrom[((phase ^ 0xff) << 1) & 0xff];
+ }
+ else
+ {
+ out = logsinrom[(phase << 1) & 0xff];
+ }
+ return OPL3_EnvelopeCalcExp(out + (envelope << 3)) ^ neg;
+}
+
+static Bit16s OPL3_EnvelopeCalcSin5(Bit16u phase, Bit16u envelope)
+{
+ Bit16u out = 0;
+ phase &= 0x3ff;
+ if (phase & 0x200)
+ {
+ out = 0x1000;
+ }
+ else if (phase & 0x80)
+ {
+ out = logsinrom[((phase ^ 0xff) << 1) & 0xff];
+ }
+ else
+ {
+ out = logsinrom[(phase << 1) & 0xff];
+ }
+ return OPL3_EnvelopeCalcExp(out + (envelope << 3));
+}
+
+static Bit16s OPL3_EnvelopeCalcSin6(Bit16u phase, Bit16u envelope)
+{
+ Bit16u neg = 0;
+ phase &= 0x3ff;
+ if (phase & 0x200)
+ {
+ neg = 0xffff;
+ }
+ return OPL3_EnvelopeCalcExp(envelope << 3) ^ neg;
+}
+
+static Bit16s OPL3_EnvelopeCalcSin7(Bit16u phase, Bit16u envelope)
+{
+ Bit16u out = 0;
+ Bit16u neg = 0;
+ phase &= 0x3ff;
+ if (phase & 0x200)
+ {
+ neg = 0xffff;
+ phase = (phase & 0x1ff) ^ 0x1ff;
+ }
+ out = phase << 3;
+ return OPL3_EnvelopeCalcExp(out + (envelope << 3)) ^ neg;
+}
+
+static const envelope_sinfunc envelope_sin[8] = {
+ OPL3_EnvelopeCalcSin0,
+ OPL3_EnvelopeCalcSin1,
+ OPL3_EnvelopeCalcSin2,
+ OPL3_EnvelopeCalcSin3,
+ OPL3_EnvelopeCalcSin4,
+ OPL3_EnvelopeCalcSin5,
+ OPL3_EnvelopeCalcSin6,
+ OPL3_EnvelopeCalcSin7
+};
+
+enum envelope_gen_num
+{
+ envelope_gen_num_attack = 0,
+ envelope_gen_num_decay = 1,
+ envelope_gen_num_sustain = 2,
+ envelope_gen_num_release = 3
+};
+
+static void OPL3_EnvelopeUpdateKSL(opl3_slot *slot)
+{
+ Bit16s ksl = (kslrom[slot->channel->f_num >> 6] << 2)
+ - ((0x08 - slot->channel->block) << 5);
+ if (ksl < 0)
+ {
+ ksl = 0;
+ }
+ slot->eg_ksl = (Bit8u)ksl;
+}
+
+static void OPL3_EnvelopeCalc(opl3_slot *slot)
+{
+ Bit8u nonzero;
+ Bit8u rate;
+ Bit8u rate_hi;
+ Bit8u rate_lo;
+ Bit8u reg_rate = 0;
+ Bit8u ks;
+ Bit8u eg_shift, shift;
+ Bit16u eg_rout;
+ Bit16s eg_inc;
+ Bit8u eg_off;
+ Bit8u reset = 0;
+ slot->eg_out = slot->eg_rout + (slot->reg_tl << 2)
+ + (slot->eg_ksl >> kslshift[slot->reg_ksl]) + *slot->trem;
+ if (slot->key && slot->eg_gen == envelope_gen_num_release)
+ {
+ reset = 1;
+ reg_rate = slot->reg_ar;
+ }
+ else
+ {
+ switch (slot->eg_gen)
+ {
+ case envelope_gen_num_attack:
+ reg_rate = slot->reg_ar;
+ break;
+ case envelope_gen_num_decay:
+ reg_rate = slot->reg_dr;
+ break;
+ case envelope_gen_num_sustain:
+ if (!slot->reg_type)
+ {
+ reg_rate = slot->reg_rr;
+ }
+ break;
+ case envelope_gen_num_release:
+ reg_rate = slot->reg_rr;
+ break;
+ }
+ }
+ slot->pg_reset = reset;
+ ks = slot->channel->ksv >> ((slot->reg_ksr ^ 1) << 1);
+ nonzero = (reg_rate != 0);
+ rate = ks + (reg_rate << 2);
+ rate_hi = rate >> 2;
+ rate_lo = rate & 0x03;
+ if (rate_hi & 0x10)
+ {
+ rate_hi = 0x0f;
+ }
+ eg_shift = rate_hi + slot->chip->eg_add;
+ shift = 0;
+ if (nonzero)
+ {
+ if (rate_hi < 12)
+ {
+ if (slot->chip->eg_state)
+ {
+ switch (eg_shift)
+ {
+ case 12:
+ shift = 1;
+ break;
+ case 13:
+ shift = (rate_lo >> 1) & 0x01;
+ break;
+ case 14:
+ shift = rate_lo & 0x01;
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ else
+ {
+ shift = (rate_hi & 0x03) + eg_incstep[rate_lo][slot->chip->timer & 0x03];
+ if (shift & 0x04)
+ {
+ shift = 0x03;
+ }
+ if (!shift)
+ {
+ shift = slot->chip->eg_state;
+ }
+ }
+ }
+ eg_rout = slot->eg_rout;
+ eg_inc = 0;
+ eg_off = 0;
+ /* Instant attack */
+ if (reset && rate_hi == 0x0f)
+ {
+ eg_rout = 0x00;
+ }
+ /* Envelope off */
+ if ((slot->eg_rout & 0x1f8) == 0x1f8)
+ {
+ eg_off = 1;
+ }
+ if (slot->eg_gen != envelope_gen_num_attack && !reset && eg_off)
+ {
+ eg_rout = 0x1ff;
+ }
+ switch (slot->eg_gen)
+ {
+ case envelope_gen_num_attack:
+ if (!slot->eg_rout)
+ {
+ slot->eg_gen = envelope_gen_num_decay;
+ }
+ else if (slot->key && shift > 0 && rate_hi != 0x0f)
+ {
+ eg_inc = ((~slot->eg_rout) << shift) >> 4;
+ }
+ break;
+ case envelope_gen_num_decay:
+ if ((slot->eg_rout >> 4) == slot->reg_sl)
+ {
+ slot->eg_gen = envelope_gen_num_sustain;
+ }
+ else if (!eg_off && !reset && shift > 0)
+ {
+ eg_inc = 1 << (shift - 1);
+ }
+ break;
+ case envelope_gen_num_sustain:
+ case envelope_gen_num_release:
+ if (!eg_off && !reset && shift > 0)
+ {
+ eg_inc = 1 << (shift - 1);
+ }
+ break;
+ }
+ slot->eg_rout = (eg_rout + eg_inc) & 0x1ff;
+ /* Key off */
+ if (reset)
+ {
+ slot->eg_gen = envelope_gen_num_attack;
+ }
+ if (!slot->key)
+ {
+ slot->eg_gen = envelope_gen_num_release;
+ }
+}
+
+static void OPL3_EnvelopeKeyOn(opl3_slot *slot, Bit8u type)
+{
+ slot->key |= type;
+}
+
+static void OPL3_EnvelopeKeyOff(opl3_slot *slot, Bit8u type)
+{
+ slot->key &= ~type;
+}
+
+/*
+ * Phase Generator
+ */
+
+static void OPL3_PhaseGenerate(opl3_slot *slot)
+{
+ opl3_chip *chip;
+ Bit16u f_num;
+ Bit32u basefreq;
+ Bit8u rm_xor, n_bit;
+ Bit32u noise;
+ Bit16u phase;
+
+ chip = slot->chip;
+ f_num = slot->channel->f_num;
+ if (slot->reg_vib)
+ {
+ Bit8s range;
+ Bit8u vibpos;
+
+ range = (f_num >> 7) & 7;
+ vibpos = slot->chip->vibpos;
+
+ if (!(vibpos & 3))
+ {
+ range = 0;
+ }
+ else if (vibpos & 1)
+ {
+ range >>= 1;
+ }
+ range >>= slot->chip->vibshift;
+
+ if (vibpos & 4)
+ {
+ range = -range;
+ }
+ f_num += range;
+ }
+ basefreq = (f_num << slot->channel->block) >> 1;
+ phase = (Bit16u)(slot->pg_phase >> 9);
+ if (slot->pg_reset)
+ {
+ slot->pg_phase = 0;
+ }
+ slot->pg_phase += (basefreq * mt[slot->reg_mult]) >> 1;
+ /* Rhythm mode */
+ noise = chip->noise;
+ slot->pg_phase_out = phase;
+ if (slot->slot_num == 13) /* hh */
+ {
+ chip->rm_hh_bit2 = (phase >> 2) & 1;
+ chip->rm_hh_bit3 = (phase >> 3) & 1;
+ chip->rm_hh_bit7 = (phase >> 7) & 1;
+ chip->rm_hh_bit8 = (phase >> 8) & 1;
+ }
+ if (slot->slot_num == 17 && (chip->rhy & 0x20)) /* tc */
+ {
+ chip->rm_tc_bit3 = (phase >> 3) & 1;
+ chip->rm_tc_bit5 = (phase >> 5) & 1;
+ }
+ if (chip->rhy & 0x20)
+ {
+ rm_xor = (chip->rm_hh_bit2 ^ chip->rm_hh_bit7)
+ | (chip->rm_hh_bit3 ^ chip->rm_tc_bit5)
+ | (chip->rm_tc_bit3 ^ chip->rm_tc_bit5);
+ switch (slot->slot_num)
+ {
+ case 13: /* hh */
+ slot->pg_phase_out = rm_xor << 9;
+ if (rm_xor ^ (noise & 1))
+ {
+ slot->pg_phase_out |= 0xd0;
+ }
+ else
+ {
+ slot->pg_phase_out |= 0x34;
+ }
+ break;
+ case 16: /* sd */
+ slot->pg_phase_out = (chip->rm_hh_bit8 << 9)
+ | ((chip->rm_hh_bit8 ^ (noise & 1)) << 8);
+ break;
+ case 17: /* tc */
+ slot->pg_phase_out = (rm_xor << 9) | 0x80;
+ break;
+ default:
+ break;
+ }
+ }
+ n_bit = ((noise >> 14) ^ noise) & 0x01;
+ chip->noise = (noise >> 1) | (n_bit << 22);
+}
+
+/*
+ * Slot
+ */
+
+static void OPL3_SlotWrite20(opl3_slot *slot, Bit8u data)
+{
+ if ((data >> 7) & 0x01)
+ {
+ slot->trem = &slot->chip->tremolo;
+ }
+ else
+ {
+ slot->trem = (Bit8u*)&slot->chip->zeromod;
+ }
+ slot->reg_vib = (data >> 6) & 0x01;
+ slot->reg_type = (data >> 5) & 0x01;
+ slot->reg_ksr = (data >> 4) & 0x01;
+ slot->reg_mult = data & 0x0f;
+}
+
+static void OPL3_SlotWrite40(opl3_slot *slot, Bit8u data)
+{
+ slot->reg_ksl = (data >> 6) & 0x03;
+ slot->reg_tl = data & 0x3f;
+ OPL3_EnvelopeUpdateKSL(slot);
+}
+
+static void OPL3_SlotWrite60(opl3_slot *slot, Bit8u data)
+{
+ slot->reg_ar = (data >> 4) & 0x0f;
+ slot->reg_dr = data & 0x0f;
+}
+
+static void OPL3_SlotWrite80(opl3_slot *slot, Bit8u data)
+{
+ slot->reg_sl = (data >> 4) & 0x0f;
+ if (slot->reg_sl == 0x0f)
+ {
+ slot->reg_sl = 0x1f;
+ }
+ slot->reg_rr = data & 0x0f;
+}
+
+static void OPL3_SlotWriteE0(opl3_slot *slot, Bit8u data)
+{
+ slot->reg_wf = data & 0x07;
+ if (slot->chip->newm == 0x00)
+ {
+ slot->reg_wf &= 0x03;
+ }
+}
+
+static void OPL3_SlotGenerate(opl3_slot *slot)
+{
+ slot->out = envelope_sin[slot->reg_wf](slot->pg_phase_out + *slot->mod, slot->eg_out);
+}
+
+static void OPL3_SlotCalcFB(opl3_slot *slot)
+{
+ if (slot->channel->fb != 0x00)
+ {
+ slot->fbmod = (slot->prout + slot->out) >> (0x09 - slot->channel->fb);
+ }
+ else
+ {
+ slot->fbmod = 0;
+ }
+ slot->prout = slot->out;
+}
+
+/*
+ * Channel
+ */
+
+static void OPL3_ChannelSetupAlg(opl3_channel *channel);
+
+static void OPL3_ChannelUpdateRhythm(opl3_chip *chip, Bit8u data)
+{
+ opl3_channel *channel6;
+ opl3_channel *channel7;
+ opl3_channel *channel8;
+ Bit8u chnum;
+
+ chip->rhy = data & 0x3f;
+ if (chip->rhy & 0x20)
+ {
+ channel6 = &chip->channel[6];
+ channel7 = &chip->channel[7];
+ channel8 = &chip->channel[8];
+ channel6->out[0] = &channel6->slots[1]->out;
+ channel6->out[1] = &channel6->slots[1]->out;
+ channel6->out[2] = &chip->zeromod;
+ channel6->out[3] = &chip->zeromod;
+ channel7->out[0] = &channel7->slots[0]->out;
+ channel7->out[1] = &channel7->slots[0]->out;
+ channel7->out[2] = &channel7->slots[1]->out;
+ channel7->out[3] = &channel7->slots[1]->out;
+ channel8->out[0] = &channel8->slots[0]->out;
+ channel8->out[1] = &channel8->slots[0]->out;
+ channel8->out[2] = &channel8->slots[1]->out;
+ channel8->out[3] = &channel8->slots[1]->out;
+ for (chnum = 6; chnum < 9; chnum++)
+ {
+ chip->channel[chnum].chtype = ch_drum;
+ }
+ OPL3_ChannelSetupAlg(channel6);
+ OPL3_ChannelSetupAlg(channel7);
+ OPL3_ChannelSetupAlg(channel8);
+ /* hh */
+ if (chip->rhy & 0x01)
+ {
+ OPL3_EnvelopeKeyOn(channel7->slots[0], egk_drum);
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOff(channel7->slots[0], egk_drum);
+ }
+ /* tc */
+ if (chip->rhy & 0x02)
+ {
+ OPL3_EnvelopeKeyOn(channel8->slots[1], egk_drum);
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOff(channel8->slots[1], egk_drum);
+ }
+ /* tom */
+ if (chip->rhy & 0x04)
+ {
+ OPL3_EnvelopeKeyOn(channel8->slots[0], egk_drum);
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOff(channel8->slots[0], egk_drum);
+ }
+ /* sd */
+ if (chip->rhy & 0x08)
+ {
+ OPL3_EnvelopeKeyOn(channel7->slots[1], egk_drum);
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOff(channel7->slots[1], egk_drum);
+ }
+ /* bd */
+ if (chip->rhy & 0x10)
+ {
+ OPL3_EnvelopeKeyOn(channel6->slots[0], egk_drum);
+ OPL3_EnvelopeKeyOn(channel6->slots[1], egk_drum);
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOff(channel6->slots[0], egk_drum);
+ OPL3_EnvelopeKeyOff(channel6->slots[1], egk_drum);
+ }
+ }
+ else
+ {
+ for (chnum = 6; chnum < 9; chnum++)
+ {
+ chip->channel[chnum].chtype = ch_2op;
+ OPL3_ChannelSetupAlg(&chip->channel[chnum]);
+ OPL3_EnvelopeKeyOff(chip->channel[chnum].slots[0], egk_drum);
+ OPL3_EnvelopeKeyOff(chip->channel[chnum].slots[1], egk_drum);
+ }
+ }
+}
+
+static void OPL3_ChannelWriteA0(opl3_channel *channel, Bit8u data)
+{
+ if (channel->chip->newm && channel->chtype == ch_4op2)
+ {
+ return;
+ }
+ channel->f_num = (channel->f_num & 0x300) | data;
+ channel->ksv = (channel->block << 1)
+ | ((channel->f_num >> (0x09 - channel->chip->nts)) & 0x01);
+ OPL3_EnvelopeUpdateKSL(channel->slots[0]);
+ OPL3_EnvelopeUpdateKSL(channel->slots[1]);
+ if (channel->chip->newm && channel->chtype == ch_4op)
+ {
+ channel->pair->f_num = channel->f_num;
+ channel->pair->ksv = channel->ksv;
+ OPL3_EnvelopeUpdateKSL(channel->pair->slots[0]);
+ OPL3_EnvelopeUpdateKSL(channel->pair->slots[1]);
+ }
+}
+
+static void OPL3_ChannelWriteB0(opl3_channel *channel, Bit8u data)
+{
+ if (channel->chip->newm && channel->chtype == ch_4op2)
+ {
+ return;
+ }
+ channel->f_num = (channel->f_num & 0xff) | ((data & 0x03) << 8);
+ channel->block = (data >> 2) & 0x07;
+ channel->ksv = (channel->block << 1)
+ | ((channel->f_num >> (0x09 - channel->chip->nts)) & 0x01);
+ OPL3_EnvelopeUpdateKSL(channel->slots[0]);
+ OPL3_EnvelopeUpdateKSL(channel->slots[1]);
+ if (channel->chip->newm && channel->chtype == ch_4op)
+ {
+ channel->pair->f_num = channel->f_num;
+ channel->pair->block = channel->block;
+ channel->pair->ksv = channel->ksv;
+ OPL3_EnvelopeUpdateKSL(channel->pair->slots[0]);
+ OPL3_EnvelopeUpdateKSL(channel->pair->slots[1]);
+ }
+}
+
+static void OPL3_ChannelSetupAlg(opl3_channel *channel)
+{
+ if (channel->chtype == ch_drum)
+ {
+ if (channel->ch_num == 7 || channel->ch_num == 8)
+ {
+ channel->slots[0]->mod = &channel->chip->zeromod;
+ channel->slots[1]->mod = &channel->chip->zeromod;
+ return;
+ }
+ switch (channel->alg & 0x01)
+ {
+ case 0x00:
+ channel->slots[0]->mod = &channel->slots[0]->fbmod;
+ channel->slots[1]->mod = &channel->slots[0]->out;
+ break;
+ case 0x01:
+ channel->slots[0]->mod = &channel->slots[0]->fbmod;
+ channel->slots[1]->mod = &channel->chip->zeromod;
+ break;
+ }
+ return;
+ }
+ if (channel->alg & 0x08)
+ {
+ return;
+ }
+ if (channel->alg & 0x04)
+ {
+ channel->pair->out[0] = &channel->chip->zeromod;
+ channel->pair->out[1] = &channel->chip->zeromod;
+ channel->pair->out[2] = &channel->chip->zeromod;
+ channel->pair->out[3] = &channel->chip->zeromod;
+ switch (channel->alg & 0x03)
+ {
+ case 0x00:
+ channel->pair->slots[0]->mod = &channel->pair->slots[0]->fbmod;
+ channel->pair->slots[1]->mod = &channel->pair->slots[0]->out;
+ channel->slots[0]->mod = &channel->pair->slots[1]->out;
+ channel->slots[1]->mod = &channel->slots[0]->out;
+ channel->out[0] = &channel->slots[1]->out;
+ channel->out[1] = &channel->chip->zeromod;
+ channel->out[2] = &channel->chip->zeromod;
+ channel->out[3] = &channel->chip->zeromod;
+ break;
+ case 0x01:
+ channel->pair->slots[0]->mod = &channel->pair->slots[0]->fbmod;
+ channel->pair->slots[1]->mod = &channel->pair->slots[0]->out;
+ channel->slots[0]->mod = &channel->chip->zeromod;
+ channel->slots[1]->mod = &channel->slots[0]->out;
+ channel->out[0] = &channel->pair->slots[1]->out;
+ channel->out[1] = &channel->slots[1]->out;
+ channel->out[2] = &channel->chip->zeromod;
+ channel->out[3] = &channel->chip->zeromod;
+ break;
+ case 0x02:
+ channel->pair->slots[0]->mod = &channel->pair->slots[0]->fbmod;
+ channel->pair->slots[1]->mod = &channel->chip->zeromod;
+ channel->slots[0]->mod = &channel->pair->slots[1]->out;
+ channel->slots[1]->mod = &channel->slots[0]->out;
+ channel->out[0] = &channel->pair->slots[0]->out;
+ channel->out[1] = &channel->slots[1]->out;
+ channel->out[2] = &channel->chip->zeromod;
+ channel->out[3] = &channel->chip->zeromod;
+ break;
+ case 0x03:
+ channel->pair->slots[0]->mod = &channel->pair->slots[0]->fbmod;
+ channel->pair->slots[1]->mod = &channel->chip->zeromod;
+ channel->slots[0]->mod = &channel->pair->slots[1]->out;
+ channel->slots[1]->mod = &channel->chip->zeromod;
+ channel->out[0] = &channel->pair->slots[0]->out;
+ channel->out[1] = &channel->slots[0]->out;
+ channel->out[2] = &channel->slots[1]->out;
+ channel->out[3] = &channel->chip->zeromod;
+ break;
+ }
+ }
+ else
+ {
+ switch (channel->alg & 0x01)
+ {
+ case 0x00:
+ channel->slots[0]->mod = &channel->slots[0]->fbmod;
+ channel->slots[1]->mod = &channel->slots[0]->out;
+ channel->out[0] = &channel->slots[1]->out;
+ channel->out[1] = &channel->chip->zeromod;
+ channel->out[2] = &channel->chip->zeromod;
+ channel->out[3] = &channel->chip->zeromod;
+ break;
+ case 0x01:
+ channel->slots[0]->mod = &channel->slots[0]->fbmod;
+ channel->slots[1]->mod = &channel->chip->zeromod;
+ channel->out[0] = &channel->slots[0]->out;
+ channel->out[1] = &channel->slots[1]->out;
+ channel->out[2] = &channel->chip->zeromod;
+ channel->out[3] = &channel->chip->zeromod;
+ break;
+ }
+ }
+}
+
+static void OPL3_ChannelWriteC0(opl3_channel *channel, Bit8u data)
+{
+ channel->fb = (data & 0x0e) >> 1;
+ channel->con = data & 0x01;
+ channel->alg = channel->con;
+ if (channel->chip->newm)
+ {
+ if (channel->chtype == ch_4op)
+ {
+ channel->pair->alg = 0x04 | (channel->con << 1) | (channel->pair->con);
+ channel->alg = 0x08;
+ OPL3_ChannelSetupAlg(channel->pair);
+ }
+ else if (channel->chtype == ch_4op2)
+ {
+ channel->alg = 0x04 | (channel->pair->con << 1) | (channel->con);
+ channel->pair->alg = 0x08;
+ OPL3_ChannelSetupAlg(channel);
+ }
+ else
+ {
+ OPL3_ChannelSetupAlg(channel);
+ }
+ }
+ else
+ {
+ OPL3_ChannelSetupAlg(channel);
+ }
+ if (channel->chip->newm)
+ {
+ channel->cha = ((data >> 4) & 0x01) ? ~0 : 0;
+ channel->chb = ((data >> 5) & 0x01) ? ~0 : 0;
+ }
+ else
+ {
+ channel->cha = channel->chb = (Bit16u)~0;
+ }
+}
+
+static void OPL3_ChannelKeyOn(opl3_channel *channel)
+{
+ if (channel->chip->newm)
+ {
+ if (channel->chtype == ch_4op)
+ {
+ OPL3_EnvelopeKeyOn(channel->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOn(channel->slots[1], egk_norm);
+ OPL3_EnvelopeKeyOn(channel->pair->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOn(channel->pair->slots[1], egk_norm);
+ }
+ else if (channel->chtype == ch_2op || channel->chtype == ch_drum)
+ {
+ OPL3_EnvelopeKeyOn(channel->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOn(channel->slots[1], egk_norm);
+ }
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOn(channel->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOn(channel->slots[1], egk_norm);
+ }
+}
+
+static void OPL3_ChannelKeyOff(opl3_channel *channel)
+{
+ if (channel->chip->newm)
+ {
+ if (channel->chtype == ch_4op)
+ {
+ OPL3_EnvelopeKeyOff(channel->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOff(channel->slots[1], egk_norm);
+ OPL3_EnvelopeKeyOff(channel->pair->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOff(channel->pair->slots[1], egk_norm);
+ }
+ else if (channel->chtype == ch_2op || channel->chtype == ch_drum)
+ {
+ OPL3_EnvelopeKeyOff(channel->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOff(channel->slots[1], egk_norm);
+ }
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOff(channel->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOff(channel->slots[1], egk_norm);
+ }
+}
+
+static void OPL3_ChannelSet4Op(opl3_chip *chip, Bit8u data)
+{
+ Bit8u bit;
+ Bit8u chnum;
+ for (bit = 0; bit < 6; bit++)
+ {
+ chnum = bit;
+ if (bit >= 3)
+ {
+ chnum += 9 - 3;
+ }
+ if ((data >> bit) & 0x01)
+ {
+ chip->channel[chnum].chtype = ch_4op;
+ chip->channel[chnum + 3].chtype = ch_4op2;
+ }
+ else
+ {
+ chip->channel[chnum].chtype = ch_2op;
+ chip->channel[chnum + 3].chtype = ch_2op;
+ }
+ }
+}
+
+static Bit16s OPL3_ClipSample(Bit32s sample)
+{
+ if (sample > 32767)
+ {
+ sample = 32767;
+ }
+ else if (sample < -32768)
+ {
+ sample = -32768;
+ }
+ return (Bit16s)sample;
+}
+
+void OPL3_Generate(opl3_chip *chip, Bit16s *buf)
+{
+ Bit8u ii;
+ Bit8u jj;
+ Bit16s accm;
+ Bit8u shift = 0;
+
+ buf[1] = OPL3_ClipSample(chip->mixbuff[1]);
+
+ for (ii = 0; ii < 15; ii++)
+ {
+ OPL3_SlotCalcFB(&chip->slot[ii]);
+ OPL3_EnvelopeCalc(&chip->slot[ii]);
+ OPL3_PhaseGenerate(&chip->slot[ii]);
+ OPL3_SlotGenerate(&chip->slot[ii]);
+ }
+
+ chip->mixbuff[0] = 0;
+ for (ii = 0; ii < 18; ii++)
+ {
+ accm = 0;
+ for (jj = 0; jj < 4; jj++)
+ {
+ accm += *chip->channel[ii].out[jj];
+ }
+ chip->mixbuff[0] += (Bit16s)(accm & chip->channel[ii].cha);
+ }
+
+ for (ii = 15; ii < 18; ii++)
+ {
+ OPL3_SlotCalcFB(&chip->slot[ii]);
+ OPL3_EnvelopeCalc(&chip->slot[ii]);
+ OPL3_PhaseGenerate(&chip->slot[ii]);
+ OPL3_SlotGenerate(&chip->slot[ii]);
+ }
+
+ buf[0] = OPL3_ClipSample(chip->mixbuff[0]);
+
+ for (ii = 18; ii < 33; ii++)
+ {
+ OPL3_SlotCalcFB(&chip->slot[ii]);
+ OPL3_EnvelopeCalc(&chip->slot[ii]);
+ OPL3_PhaseGenerate(&chip->slot[ii]);
+ OPL3_SlotGenerate(&chip->slot[ii]);
+ }
+
+ chip->mixbuff[1] = 0;
+ for (ii = 0; ii < 18; ii++)
+ {
+ accm = 0;
+ for (jj = 0; jj < 4; jj++)
+ {
+ accm += *chip->channel[ii].out[jj];
+ }
+ chip->mixbuff[1] += (Bit16s)(accm & chip->channel[ii].chb);
+ }
+
+ for (ii = 33; ii < 36; ii++)
+ {
+ OPL3_SlotCalcFB(&chip->slot[ii]);
+ OPL3_EnvelopeCalc(&chip->slot[ii]);
+ OPL3_PhaseGenerate(&chip->slot[ii]);
+ OPL3_SlotGenerate(&chip->slot[ii]);
+ }
+
+ if ((chip->timer & 0x3f) == 0x3f)
+ {
+ chip->tremolopos = (chip->tremolopos + 1) % 210;
+ }
+ if (chip->tremolopos < 105)
+ {
+ chip->tremolo = chip->tremolopos >> chip->tremoloshift;
+ }
+ else
+ {
+ chip->tremolo = (210 - chip->tremolopos) >> chip->tremoloshift;
+ }
+
+ if ((chip->timer & 0x3ff) == 0x3ff)
+ {
+ chip->vibpos = (chip->vibpos + 1) & 7;
+ }
+
+ chip->timer++;
+
+ chip->eg_add = 0;
+ if (chip->eg_timer)
+ {
+ while (shift < 36 && ((chip->eg_timer >> shift) & 1) == 0)
+ {
+ shift++;
+ }
+ if (shift > 12)
+ {
+ chip->eg_add = 0;
+ }
+ else
+ {
+ chip->eg_add = shift + 1;
+ }
+ }
+
+ if (chip->eg_timerrem || chip->eg_state)
+ {
+ if (chip->eg_timer == 0xfffffffff)
+ {
+ chip->eg_timer = 0;
+ chip->eg_timerrem = 1;
+ }
+ else
+ {
+ chip->eg_timer++;
+ chip->eg_timerrem = 0;
+ }
+ }
+
+ chip->eg_state ^= 1;
+
+ while (chip->writebuf[chip->writebuf_cur].time <= chip->writebuf_samplecnt)
+ {
+ if (!(chip->writebuf[chip->writebuf_cur].reg & 0x200))
+ {
+ break;
+ }
+ chip->writebuf[chip->writebuf_cur].reg &= 0x1ff;
+ OPL3_WriteReg(chip, chip->writebuf[chip->writebuf_cur].reg,
+ chip->writebuf[chip->writebuf_cur].data);
+ chip->writebuf_cur = (chip->writebuf_cur + 1) % OPL_WRITEBUF_SIZE;
+ }
+ chip->writebuf_samplecnt++;
+}
+
+void OPL3_GenerateResampled(opl3_chip *chip, Bit16s *buf)
+{
+ while (chip->samplecnt >= chip->rateratio)
+ {
+ chip->oldsamples[0] = chip->samples[0];
+ chip->oldsamples[1] = chip->samples[1];
+ OPL3_Generate(chip, chip->samples);
+ chip->samplecnt -= chip->rateratio;
+ }
+ buf[0] = (Bit16s)((chip->oldsamples[0] * (chip->rateratio - chip->samplecnt)
+ + chip->samples[0] * chip->samplecnt) / chip->rateratio);
+ buf[1] = (Bit16s)((chip->oldsamples[1] * (chip->rateratio - chip->samplecnt)
+ + chip->samples[1] * chip->samplecnt) / chip->rateratio);
+ chip->samplecnt += 1 << RSM_FRAC;
+}
+
+void OPL3_Reset(opl3_chip *chip, Bit32u samplerate)
+{
+ Bit8u slotnum;
+ Bit8u channum;
+
+ memset(chip, 0, sizeof(opl3_chip));
+ for (slotnum = 0; slotnum < 36; slotnum++)
+ {
+ chip->slot[slotnum].chip = chip;
+ chip->slot[slotnum].mod = &chip->zeromod;
+ chip->slot[slotnum].eg_rout = 0x1ff;
+ chip->slot[slotnum].eg_out = 0x1ff;
+ chip->slot[slotnum].eg_gen = envelope_gen_num_release;
+ chip->slot[slotnum].trem = (Bit8u*)&chip->zeromod;
+ chip->slot[slotnum].slot_num = slotnum;
+ }
+ for (channum = 0; channum < 18; channum++)
+ {
+ chip->channel[channum].slots[0] = &chip->slot[ch_slot[channum]];
+ chip->channel[channum].slots[1] = &chip->slot[ch_slot[channum] + 3];
+ chip->slot[ch_slot[channum]].channel = &chip->channel[channum];
+ chip->slot[ch_slot[channum] + 3].channel = &chip->channel[channum];
+ if ((channum % 9) < 3)
+ {
+ chip->channel[channum].pair = &chip->channel[channum + 3];
+ }
+ else if ((channum % 9) < 6)
+ {
+ chip->channel[channum].pair = &chip->channel[channum - 3];
+ }
+ chip->channel[channum].chip = chip;
+ chip->channel[channum].out[0] = &chip->zeromod;
+ chip->channel[channum].out[1] = &chip->zeromod;
+ chip->channel[channum].out[2] = &chip->zeromod;
+ chip->channel[channum].out[3] = &chip->zeromod;
+ chip->channel[channum].chtype = ch_2op;
+ chip->channel[channum].cha = 0xffff;
+ chip->channel[channum].chb = 0xffff;
+ chip->channel[channum].ch_num = channum;
+ OPL3_ChannelSetupAlg(&chip->channel[channum]);
+ }
+ chip->noise = 1;
+ chip->rateratio = (samplerate << RSM_FRAC) / 49716;
+ chip->tremoloshift = 4;
+ chip->vibshift = 1;
+}
+
+void OPL3_WriteReg(opl3_chip *chip, Bit16u reg, Bit8u v)
+{
+ Bit8u high = (reg >> 8) & 0x01;
+ Bit8u regm = reg & 0xff;
+ switch (regm & 0xf0)
+ {
+ case 0x00:
+ if (high)
+ {
+ switch (regm & 0x0f)
+ {
+ case 0x04:
+ OPL3_ChannelSet4Op(chip, v);
+ break;
+ case 0x05:
+ chip->newm = v & 0x01;
+ break;
+ }
+ }
+ else
+ {
+ switch (regm & 0x0f)
+ {
+ case 0x08:
+ chip->nts = (v >> 6) & 0x01;
+ break;
+ }
+ }
+ break;
+ case 0x20:
+ case 0x30:
+ if (ad_slot[regm & 0x1f] >= 0)
+ {
+ OPL3_SlotWrite20(&chip->slot[18 * high + ad_slot[regm & 0x1f]], v);
+ }
+ break;
+ case 0x40:
+ case 0x50:
+ if (ad_slot[regm & 0x1f] >= 0)
+ {
+ OPL3_SlotWrite40(&chip->slot[18 * high + ad_slot[regm & 0x1f]], v);
+ }
+ break;
+ case 0x60:
+ case 0x70:
+ if (ad_slot[regm & 0x1f] >= 0)
+ {
+ OPL3_SlotWrite60(&chip->slot[18 * high + ad_slot[regm & 0x1f]], v);
+ }
+ break;
+ case 0x80:
+ case 0x90:
+ if (ad_slot[regm & 0x1f] >= 0)
+ {
+ OPL3_SlotWrite80(&chip->slot[18 * high + ad_slot[regm & 0x1f]], v);
+ }
+ break;
+ case 0xe0:
+ case 0xf0:
+ if (ad_slot[regm & 0x1f] >= 0)
+ {
+ OPL3_SlotWriteE0(&chip->slot[18 * high + ad_slot[regm & 0x1f]], v);
+ }
+ break;
+ case 0xa0:
+ if ((regm & 0x0f) < 9)
+ {
+ OPL3_ChannelWriteA0(&chip->channel[9 * high + (regm & 0x0f)], v);
+ }
+ break;
+ case 0xb0:
+ if (regm == 0xbd && !high)
+ {
+ chip->tremoloshift = (((v >> 7) ^ 1) << 1) + 2;
+ chip->vibshift = ((v >> 6) & 0x01) ^ 1;
+ OPL3_ChannelUpdateRhythm(chip, v);
+ }
+ else if ((regm & 0x0f) < 9)
+ {
+ OPL3_ChannelWriteB0(&chip->channel[9 * high + (regm & 0x0f)], v);
+ if (v & 0x20)
+ {
+ OPL3_ChannelKeyOn(&chip->channel[9 * high + (regm & 0x0f)]);
+ }
+ else
+ {
+ OPL3_ChannelKeyOff(&chip->channel[9 * high + (regm & 0x0f)]);
+ }
+ }
+ break;
+ case 0xc0:
+ if ((regm & 0x0f) < 9)
+ {
+ OPL3_ChannelWriteC0(&chip->channel[9 * high + (regm & 0x0f)], v);
+ }
+ break;
+ }
+}
+
+void OPL3_WriteRegBuffered(opl3_chip *chip, Bit16u reg, Bit8u v)
+{
+ Bit64u time1, time2;
+
+ if (chip->writebuf[chip->writebuf_last].reg & 0x200)
+ {
+ OPL3_WriteReg(chip, chip->writebuf[chip->writebuf_last].reg & 0x1ff,
+ chip->writebuf[chip->writebuf_last].data);
+
+ chip->writebuf_cur = (chip->writebuf_last + 1) % OPL_WRITEBUF_SIZE;
+ chip->writebuf_samplecnt = chip->writebuf[chip->writebuf_last].time;
+ }
+
+ chip->writebuf[chip->writebuf_last].reg = reg | 0x200;
+ chip->writebuf[chip->writebuf_last].data = v;
+ time1 = chip->writebuf_lasttime + OPL_WRITEBUF_DELAY;
+ time2 = chip->writebuf_samplecnt;
+
+ if (time1 < time2)
+ {
+ time1 = time2;
+ }
+
+ chip->writebuf[chip->writebuf_last].time = time1;
+ chip->writebuf_lasttime = time1;
+ chip->writebuf_last = (chip->writebuf_last + 1) % OPL_WRITEBUF_SIZE;
+}
+
+void OPL3_GenerateStream(opl3_chip *chip, Bit16s *sndptr, Bit32u numsamples)
+{
+ Bit32u i;
+
+ for(i = 0; i < numsamples; i++)
+ {
+ OPL3_GenerateResampled(chip, sndptr);
+ sndptr += 2;
+ }
+}
+
+void OPL3_GenerateStreamMix(opl3_chip *chip, Bit16s *sndptr, Bit32u numsamples)
+{
+ Bit32u i;
+ Bit16s sample[2];
+
+ for(i = 0; i < numsamples; i++)
+ {
+ OPL3_GenerateResampled(chip, sample);
+ sndptr[0] += sample[0];
+ sndptr[1] += sample[1];
+ sndptr += 2;
+ }
+}
diff --git a/src/chips/nuked/nukedopl3.h b/src/chips/nuked/nukedopl3.h
new file mode 100644
index 0000000..ce748b1
--- /dev/null
+++ b/src/chips/nuked/nukedopl3.h
@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 2013-2018 Alexey Khokholov (Nuke.YKT)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ *
+ * Nuked OPL3 emulator.
+ * Thanks:
+ * MAME Development Team(Jarek Burczynski, Tatsuyuki Satoh):
+ * Feedback and Rhythm part calculation information.
+ * forums.submarine.org.uk(carbon14, opl3):
+ * Tremolo and phase generator calculation information.
+ * OPLx decapsulated(Matthew Gambrell, Olli Niemitalo):
+ * OPL2 ROMs.
+ * siliconpr0n.org(John McMaster, digshadow):
+ * YMF262 and VRC VII decaps and die shots.
+ *
+ * version: 1.8
+ */
+
+#ifndef OPL_OPL3_H
+#define OPL_OPL3_H
+
+#include <inttypes.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define OPL_WRITEBUF_SIZE 1024
+#define OPL_WRITEBUF_DELAY 2
+
+typedef uintptr_t Bitu;
+typedef intptr_t Bits;
+typedef uint64_t Bit64u;
+typedef int64_t Bit64s;
+typedef uint32_t Bit32u;
+typedef int32_t Bit32s;
+typedef uint16_t Bit16u;
+typedef int16_t Bit16s;
+typedef uint8_t Bit8u;
+typedef int8_t Bit8s;
+
+typedef struct _opl3_slot opl3_slot;
+typedef struct _opl3_channel opl3_channel;
+typedef struct _opl3_chip opl3_chip;
+
+struct _opl3_slot {
+ opl3_channel *channel;
+ opl3_chip *chip;
+ Bit16s out;
+ Bit16s fbmod;
+ Bit16s *mod;
+ Bit16s prout;
+ Bit16s eg_rout;
+ Bit16s eg_out;
+ Bit8u eg_inc;
+ Bit8u eg_gen;
+ Bit8u eg_rate;
+ Bit8u eg_ksl;
+ Bit8u *trem;
+ Bit8u reg_vib;
+ Bit8u reg_type;
+ Bit8u reg_ksr;
+ Bit8u reg_mult;
+ Bit8u reg_ksl;
+ Bit8u reg_tl;
+ Bit8u reg_ar;
+ Bit8u reg_dr;
+ Bit8u reg_sl;
+ Bit8u reg_rr;
+ Bit8u reg_wf;
+ Bit8u key;
+ Bit32u pg_reset;
+ Bit32u pg_phase;
+ Bit16u pg_phase_out;
+ Bit8u slot_num;
+};
+
+struct _opl3_channel {
+ opl3_slot *slots[2];
+ opl3_channel *pair;
+ opl3_chip *chip;
+ Bit16s *out[4];
+ Bit8u chtype;
+ Bit16u f_num;
+ Bit8u block;
+ Bit8u fb;
+ Bit8u con;
+ Bit8u alg;
+ Bit8u ksv;
+ Bit16u cha, chb;
+ Bit8u ch_num;
+};
+
+typedef struct _opl3_writebuf {
+ Bit64u time;
+ Bit16u reg;
+ Bit8u data;
+} opl3_writebuf;
+
+struct _opl3_chip {
+ opl3_channel channel[18];
+ opl3_slot slot[36];
+ Bit16u timer;
+ Bit64u eg_timer;
+ Bit8u eg_timerrem;
+ Bit8u eg_state;
+ Bit8u eg_add;
+ Bit8u newm;
+ Bit8u nts;
+ Bit8u rhy;
+ Bit8u vibpos;
+ Bit8u vibshift;
+ Bit8u tremolo;
+ Bit8u tremolopos;
+ Bit8u tremoloshift;
+ Bit32u noise;
+ Bit16s zeromod;
+ Bit32s mixbuff[2];
+ Bit8u rm_hh_bit2;
+ Bit8u rm_hh_bit3;
+ Bit8u rm_hh_bit7;
+ Bit8u rm_hh_bit8;
+ Bit8u rm_tc_bit3;
+ Bit8u rm_tc_bit5;
+ /* OPL3L */
+ Bit32s rateratio;
+ Bit32s samplecnt;
+ Bit16s oldsamples[2];
+ Bit16s samples[2];
+
+ Bit64u writebuf_samplecnt;
+ Bit32u writebuf_cur;
+ Bit32u writebuf_last;
+ Bit64u writebuf_lasttime;
+ opl3_writebuf writebuf[OPL_WRITEBUF_SIZE];
+};
+
+void OPL3_Generate(opl3_chip *chip, Bit16s *buf);
+void OPL3_GenerateResampled(opl3_chip *chip, Bit16s *buf);
+void OPL3_Reset(opl3_chip *chip, Bit32u samplerate);
+void OPL3_WriteReg(opl3_chip *chip, Bit16u reg, Bit8u v);
+void OPL3_WriteRegBuffered(opl3_chip *chip, Bit16u reg, Bit8u v);
+void OPL3_GenerateStream(opl3_chip *chip, Bit16s *sndptr, Bit32u numsamples);
+void OPL3_GenerateStreamMix(opl3_chip *chip, Bit16s *sndptr, Bit32u numsamples);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/chips/nuked/nukedopl3_174.c b/src/chips/nuked/nukedopl3_174.c
new file mode 100644
index 0000000..401089c
--- /dev/null
+++ b/src/chips/nuked/nukedopl3_174.c
@@ -0,0 +1,1391 @@
+/*
+ * Copyright (C) 2013-2016 Alexey Khokholov (Nuke.YKT)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Nuked OPL3 emulator.
+ * Thanks:
+ * MAME Development Team(Jarek Burczynski, Tatsuyuki Satoh):
+ * Feedback and Rhythm part calculation information.
+ * forums.submarine.org.uk(carbon14, opl3):
+ * Tremolo and phase generator calculation information.
+ * OPLx decapsulated(Matthew Gambrell, Olli Niemitalo):
+ * OPL2 ROMs.
+ *
+ * version: 1.7.4
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "nukedopl3_174.h"
+
+#define RSM_FRAC 10
+
+/* Channel types */
+
+enum {
+ ch_2op = 0,
+ ch_4op = 1,
+ ch_4op2 = 2,
+ ch_drum = 3
+};
+
+/* Envelope key types */
+
+enum {
+ egk_norm = 0x01,
+ egk_drum = 0x02
+};
+
+
+/*
+ * logsin table
+ */
+
+static const Bit16u logsinrom[512] = {
+ 0x859, 0x6c3, 0x607, 0x58b, 0x52e, 0x4e4, 0x4a6, 0x471,
+ 0x443, 0x41a, 0x3f5, 0x3d3, 0x3b5, 0x398, 0x37e, 0x365,
+ 0x34e, 0x339, 0x324, 0x311, 0x2ff, 0x2ed, 0x2dc, 0x2cd,
+ 0x2bd, 0x2af, 0x2a0, 0x293, 0x286, 0x279, 0x26d, 0x261,
+ 0x256, 0x24b, 0x240, 0x236, 0x22c, 0x222, 0x218, 0x20f,
+ 0x206, 0x1fd, 0x1f5, 0x1ec, 0x1e4, 0x1dc, 0x1d4, 0x1cd,
+ 0x1c5, 0x1be, 0x1b7, 0x1b0, 0x1a9, 0x1a2, 0x19b, 0x195,
+ 0x18f, 0x188, 0x182, 0x17c, 0x177, 0x171, 0x16b, 0x166,
+ 0x160, 0x15b, 0x155, 0x150, 0x14b, 0x146, 0x141, 0x13c,
+ 0x137, 0x133, 0x12e, 0x129, 0x125, 0x121, 0x11c, 0x118,
+ 0x114, 0x10f, 0x10b, 0x107, 0x103, 0x0ff, 0x0fb, 0x0f8,
+ 0x0f4, 0x0f0, 0x0ec, 0x0e9, 0x0e5, 0x0e2, 0x0de, 0x0db,
+ 0x0d7, 0x0d4, 0x0d1, 0x0cd, 0x0ca, 0x0c7, 0x0c4, 0x0c1,
+ 0x0be, 0x0bb, 0x0b8, 0x0b5, 0x0b2, 0x0af, 0x0ac, 0x0a9,
+ 0x0a7, 0x0a4, 0x0a1, 0x09f, 0x09c, 0x099, 0x097, 0x094,
+ 0x092, 0x08f, 0x08d, 0x08a, 0x088, 0x086, 0x083, 0x081,
+ 0x07f, 0x07d, 0x07a, 0x078, 0x076, 0x074, 0x072, 0x070,
+ 0x06e, 0x06c, 0x06a, 0x068, 0x066, 0x064, 0x062, 0x060,
+ 0x05e, 0x05c, 0x05b, 0x059, 0x057, 0x055, 0x053, 0x052,
+ 0x050, 0x04e, 0x04d, 0x04b, 0x04a, 0x048, 0x046, 0x045,
+ 0x043, 0x042, 0x040, 0x03f, 0x03e, 0x03c, 0x03b, 0x039,
+ 0x038, 0x037, 0x035, 0x034, 0x033, 0x031, 0x030, 0x02f,
+ 0x02e, 0x02d, 0x02b, 0x02a, 0x029, 0x028, 0x027, 0x026,
+ 0x025, 0x024, 0x023, 0x022, 0x021, 0x020, 0x01f, 0x01e,
+ 0x01d, 0x01c, 0x01b, 0x01a, 0x019, 0x018, 0x017, 0x017,
+ 0x016, 0x015, 0x014, 0x014, 0x013, 0x012, 0x011, 0x011,
+ 0x010, 0x00f, 0x00f, 0x00e, 0x00d, 0x00d, 0x00c, 0x00c,
+ 0x00b, 0x00a, 0x00a, 0x009, 0x009, 0x008, 0x008, 0x007,
+ 0x007, 0x007, 0x006, 0x006, 0x005, 0x005, 0x005, 0x004,
+ 0x004, 0x004, 0x003, 0x003, 0x003, 0x002, 0x002, 0x002,
+ 0x002, 0x001, 0x001, 0x001, 0x001, 0x001, 0x001, 0x001,
+ 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000,
+ 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000,
+ 0x001, 0x001, 0x001, 0x001, 0x001, 0x001, 0x001, 0x002,
+ 0x002, 0x002, 0x002, 0x003, 0x003, 0x003, 0x004, 0x004,
+ 0x004, 0x005, 0x005, 0x005, 0x006, 0x006, 0x007, 0x007,
+ 0x007, 0x008, 0x008, 0x009, 0x009, 0x00a, 0x00a, 0x00b,
+ 0x00c, 0x00c, 0x00d, 0x00d, 0x00e, 0x00f, 0x00f, 0x010,
+ 0x011, 0x011, 0x012, 0x013, 0x014, 0x014, 0x015, 0x016,
+ 0x017, 0x017, 0x018, 0x019, 0x01a, 0x01b, 0x01c, 0x01d,
+ 0x01e, 0x01f, 0x020, 0x021, 0x022, 0x023, 0x024, 0x025,
+ 0x026, 0x027, 0x028, 0x029, 0x02a, 0x02b, 0x02d, 0x02e,
+ 0x02f, 0x030, 0x031, 0x033, 0x034, 0x035, 0x037, 0x038,
+ 0x039, 0x03b, 0x03c, 0x03e, 0x03f, 0x040, 0x042, 0x043,
+ 0x045, 0x046, 0x048, 0x04a, 0x04b, 0x04d, 0x04e, 0x050,
+ 0x052, 0x053, 0x055, 0x057, 0x059, 0x05b, 0x05c, 0x05e,
+ 0x060, 0x062, 0x064, 0x066, 0x068, 0x06a, 0x06c, 0x06e,
+ 0x070, 0x072, 0x074, 0x076, 0x078, 0x07a, 0x07d, 0x07f,
+ 0x081, 0x083, 0x086, 0x088, 0x08a, 0x08d, 0x08f, 0x092,
+ 0x094, 0x097, 0x099, 0x09c, 0x09f, 0x0a1, 0x0a4, 0x0a7,
+ 0x0a9, 0x0ac, 0x0af, 0x0b2, 0x0b5, 0x0b8, 0x0bb, 0x0be,
+ 0x0c1, 0x0c4, 0x0c7, 0x0ca, 0x0cd, 0x0d1, 0x0d4, 0x0d7,
+ 0x0db, 0x0de, 0x0e2, 0x0e5, 0x0e9, 0x0ec, 0x0f0, 0x0f4,
+ 0x0f8, 0x0fb, 0x0ff, 0x103, 0x107, 0x10b, 0x10f, 0x114,
+ 0x118, 0x11c, 0x121, 0x125, 0x129, 0x12e, 0x133, 0x137,
+ 0x13c, 0x141, 0x146, 0x14b, 0x150, 0x155, 0x15b, 0x160,
+ 0x166, 0x16b, 0x171, 0x177, 0x17c, 0x182, 0x188, 0x18f,
+ 0x195, 0x19b, 0x1a2, 0x1a9, 0x1b0, 0x1b7, 0x1be, 0x1c5,
+ 0x1cd, 0x1d4, 0x1dc, 0x1e4, 0x1ec, 0x1f5, 0x1fd, 0x206,
+ 0x20f, 0x218, 0x222, 0x22c, 0x236, 0x240, 0x24b, 0x256,
+ 0x261, 0x26d, 0x279, 0x286, 0x293, 0x2a0, 0x2af, 0x2bd,
+ 0x2cd, 0x2dc, 0x2ed, 0x2ff, 0x311, 0x324, 0x339, 0x34e,
+ 0x365, 0x37e, 0x398, 0x3b5, 0x3d3, 0x3f5, 0x41a, 0x443,
+ 0x471, 0x4a6, 0x4e4, 0x52e, 0x58b, 0x607, 0x6c3, 0x859
+};
+
+/*
+ * exp table
+ */
+
+static const Bit16u exprom[256] = {
+ 0xff4, 0xfea, 0xfde, 0xfd4, 0xfc8, 0xfbe, 0xfb4, 0xfa8,
+ 0xf9e, 0xf92, 0xf88, 0xf7e, 0xf72, 0xf68, 0xf5c, 0xf52,
+ 0xf48, 0xf3e, 0xf32, 0xf28, 0xf1e, 0xf14, 0xf08, 0xefe,
+ 0xef4, 0xeea, 0xee0, 0xed4, 0xeca, 0xec0, 0xeb6, 0xeac,
+ 0xea2, 0xe98, 0xe8e, 0xe84, 0xe7a, 0xe70, 0xe66, 0xe5c,
+ 0xe52, 0xe48, 0xe3e, 0xe34, 0xe2a, 0xe20, 0xe16, 0xe0c,
+ 0xe04, 0xdfa, 0xdf0, 0xde6, 0xddc, 0xdd2, 0xdca, 0xdc0,
+ 0xdb6, 0xdac, 0xda4, 0xd9a, 0xd90, 0xd88, 0xd7e, 0xd74,
+ 0xd6a, 0xd62, 0xd58, 0xd50, 0xd46, 0xd3c, 0xd34, 0xd2a,
+ 0xd22, 0xd18, 0xd10, 0xd06, 0xcfe, 0xcf4, 0xcec, 0xce2,
+ 0xcda, 0xcd0, 0xcc8, 0xcbe, 0xcb6, 0xcae, 0xca4, 0xc9c,
+ 0xc92, 0xc8a, 0xc82, 0xc78, 0xc70, 0xc68, 0xc60, 0xc56,
+ 0xc4e, 0xc46, 0xc3c, 0xc34, 0xc2c, 0xc24, 0xc1c, 0xc12,
+ 0xc0a, 0xc02, 0xbfa, 0xbf2, 0xbea, 0xbe0, 0xbd8, 0xbd0,
+ 0xbc8, 0xbc0, 0xbb8, 0xbb0, 0xba8, 0xba0, 0xb98, 0xb90,
+ 0xb88, 0xb80, 0xb78, 0xb70, 0xb68, 0xb60, 0xb58, 0xb50,
+ 0xb48, 0xb40, 0xb38, 0xb32, 0xb2a, 0xb22, 0xb1a, 0xb12,
+ 0xb0a, 0xb02, 0xafc, 0xaf4, 0xaec, 0xae4, 0xade, 0xad6,
+ 0xace, 0xac6, 0xac0, 0xab8, 0xab0, 0xaa8, 0xaa2, 0xa9a,
+ 0xa92, 0xa8c, 0xa84, 0xa7c, 0xa76, 0xa6e, 0xa68, 0xa60,
+ 0xa58, 0xa52, 0xa4a, 0xa44, 0xa3c, 0xa36, 0xa2e, 0xa28,
+ 0xa20, 0xa18, 0xa12, 0xa0c, 0xa04, 0x9fe, 0x9f6, 0x9f0,
+ 0x9e8, 0x9e2, 0x9da, 0x9d4, 0x9ce, 0x9c6, 0x9c0, 0x9b8,
+ 0x9b2, 0x9ac, 0x9a4, 0x99e, 0x998, 0x990, 0x98a, 0x984,
+ 0x97c, 0x976, 0x970, 0x96a, 0x962, 0x95c, 0x956, 0x950,
+ 0x948, 0x942, 0x93c, 0x936, 0x930, 0x928, 0x922, 0x91c,
+ 0x916, 0x910, 0x90a, 0x904, 0x8fc, 0x8f6, 0x8f0, 0x8ea,
+ 0x8e4, 0x8de, 0x8d8, 0x8d2, 0x8cc, 0x8c6, 0x8c0, 0x8ba,
+ 0x8b4, 0x8ae, 0x8a8, 0x8a2, 0x89c, 0x896, 0x890, 0x88a,
+ 0x884, 0x87e, 0x878, 0x872, 0x86c, 0x866, 0x860, 0x85a,
+ 0x854, 0x850, 0x84a, 0x844, 0x83e, 0x838, 0x832, 0x82c,
+ 0x828, 0x822, 0x81c, 0x816, 0x810, 0x80c, 0x806, 0x800
+};
+
+/*
+ * freq mult table multiplied by 2
+ *
+ * 1/2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 12, 12, 15, 15
+ */
+
+static const Bit8u mt[16] = {
+ 1, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 20, 24, 24, 30, 30
+};
+
+/*
+ * ksl table
+ */
+
+static const Bit8u kslrom[16] = {
+ 0, 32, 40, 45, 48, 51, 53, 55, 56, 58, 59, 60, 61, 62, 63, 64
+};
+
+static const Bit8u kslshift[4] = {
+ 8, 1, 2, 0
+};
+
+/*
+ * envelope generator constants
+ */
+
+static const Bit8u eg_incstep[3][4][8] = {
+ {
+ { 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, 0, 0, 0, 0, 0, 0, 0 }
+ },
+ {
+ { 0, 1, 0, 1, 0, 1, 0, 1 },
+ { 0, 1, 0, 1, 1, 1, 0, 1 },
+ { 0, 1, 1, 1, 0, 1, 1, 1 },
+ { 0, 1, 1, 1, 1, 1, 1, 1 }
+ },
+ {
+ { 1, 1, 1, 1, 1, 1, 1, 1 },
+ { 2, 2, 1, 1, 1, 1, 1, 1 },
+ { 2, 2, 1, 1, 2, 2, 1, 1 },
+ { 2, 2, 2, 2, 2, 2, 1, 1 }
+ }
+};
+
+static const Bit8u eg_incdesc[16] = {
+ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2
+};
+
+static const Bit8s eg_incsh[16] = {
+ 0, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, -1, -2
+};
+
+/*
+ * address decoding
+ */
+
+static const Bit8s ad_slot[0x20] = {
+ 0, 1, 2, 3, 4, 5, -1, -1, 6, 7, 8, 9, 10, 11, -1, -1,
+ 12, 13, 14, 15, 16, 17, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+};
+
+static const Bit8u ch_slot[18] = {
+ 0, 1, 2, 6, 7, 8, 12, 13, 14, 18, 19, 20, 24, 25, 26, 30, 31, 32
+};
+
+/*
+ * Envelope generator
+ */
+
+static void OPL3_EnvelopeGenOff(opl3_slot *slot);
+static void OPL3_EnvelopeGenAttack(opl3_slot *slot);
+static void OPL3_EnvelopeGenDecay(opl3_slot *slot);
+static void OPL3_EnvelopeGenSustain(opl3_slot *slot);
+static void OPL3_EnvelopeGenRelease(opl3_slot *slot);
+
+typedef void(*envelope_genfunc)(opl3_slot *slot);
+
+envelope_genfunc envelope_gen[5] = {
+ OPL3_EnvelopeGenOff,
+ OPL3_EnvelopeGenAttack,
+ OPL3_EnvelopeGenDecay,
+ OPL3_EnvelopeGenSustain,
+ OPL3_EnvelopeGenRelease
+};
+
+enum envelope_gen_num
+{
+ envelope_gen_num_off = 0,
+ envelope_gen_num_attack = 1,
+ envelope_gen_num_decay = 2,
+ envelope_gen_num_sustain = 3,
+ envelope_gen_num_release = 4
+};
+
+static Bit8u OPL3_EnvelopeCalcRate(opl3_slot *slot, Bit8u reg_rate)
+{
+ Bit8u rate;
+ if (reg_rate == 0x00)
+ {
+ return 0x00;
+ }
+ rate = (reg_rate << 2)
+ + (slot->reg_ksr ? slot->channel->ksv : (slot->channel->ksv >> 2));
+ if (rate > 0x3c)
+ {
+ rate = 0x3c;
+ }
+ return rate;
+}
+
+static void OPL3_EnvelopeUpdateKSL(opl3_slot *slot)
+{
+ Bit16s ksl = (kslrom[slot->channel->f_num >> 6] << 2)
+ - ((0x08 - slot->channel->block) << 5);
+ if (ksl < 0)
+ {
+ ksl = 0;
+ }
+ slot->eg_ksl = (Bit8u)ksl;
+}
+
+static void OPL3_EnvelopeUpdateRate(opl3_slot *slot)
+{
+ switch (slot->eg_gen)
+ {
+ case envelope_gen_num_off:
+ case envelope_gen_num_attack:
+ slot->eg_rate = OPL3_EnvelopeCalcRate(slot, slot->reg_ar);
+ break;
+ case envelope_gen_num_decay:
+ slot->eg_rate = OPL3_EnvelopeCalcRate(slot, slot->reg_dr);
+ break;
+ case envelope_gen_num_sustain:
+ case envelope_gen_num_release:
+ slot->eg_rate = OPL3_EnvelopeCalcRate(slot, slot->reg_rr);
+ break;
+ }
+}
+
+static void OPL3_EnvelopeGenOff(opl3_slot *slot)
+{
+ slot->eg_rout = 0x1ff;
+}
+
+static void OPL3_EnvelopeGenAttack(opl3_slot *slot)
+{
+ if (slot->eg_rout == 0x00)
+ {
+ slot->eg_gen = envelope_gen_num_decay;
+ OPL3_EnvelopeUpdateRate(slot);
+ return;
+ }
+ slot->eg_rout += ((~slot->eg_rout) * slot->eg_inc) >> 3;
+ if (slot->eg_rout < 0x00)
+ {
+ slot->eg_rout = 0x00;
+ }
+}
+
+static void OPL3_EnvelopeGenDecay(opl3_slot *slot)
+{
+ if (slot->eg_rout >= slot->reg_sl << 4)
+ {
+ slot->eg_gen = envelope_gen_num_sustain;
+ OPL3_EnvelopeUpdateRate(slot);
+ return;
+ }
+ slot->eg_rout += slot->eg_inc;
+}
+
+static void OPL3_EnvelopeGenSustain(opl3_slot *slot)
+{
+ if (!slot->reg_type)
+ {
+ OPL3_EnvelopeGenRelease(slot);
+ }
+}
+
+static void OPL3_EnvelopeGenRelease(opl3_slot *slot)
+{
+ if (slot->eg_rout >= 0x1ff)
+ {
+ slot->eg_gen = envelope_gen_num_off;
+ slot->eg_rout = 0x1ff;
+ OPL3_EnvelopeUpdateRate(slot);
+ return;
+ }
+ slot->eg_rout += slot->eg_inc;
+}
+
+static void OPL3_EnvelopeCalc(opl3_slot *slot)
+{
+ Bit8u rate_h, rate_l;
+ Bit8u inc = 0;
+ rate_h = slot->eg_rate >> 2;
+ rate_l = slot->eg_rate & 3;
+ if (eg_incsh[rate_h] > 0)
+ {
+ if ((slot->chip->timer & ((1 << eg_incsh[rate_h]) - 1)) == 0)
+ {
+ inc = eg_incstep[eg_incdesc[rate_h]][rate_l]
+ [((slot->chip->timer)>> eg_incsh[rate_h]) & 0x07];
+ }
+ }
+ else
+ {
+ inc = eg_incstep[eg_incdesc[rate_h]][rate_l]
+ [slot->chip->timer & 0x07] << (-eg_incsh[rate_h]);
+ }
+ slot->eg_inc = inc;
+ slot->eg_out = slot->eg_rout + (slot->reg_tl << 2)
+ + (slot->eg_ksl >> kslshift[slot->reg_ksl]) + *slot->trem;
+ if (slot->eg_out > 0x1ff) /* TODO: Remove this if possible */
+ {
+ slot->eg_out = 0x1ff;
+ }
+ slot->eg_out <<= 3;
+
+ envelope_gen[slot->eg_gen](slot);
+}
+
+static void OPL3_EnvelopeKeyOn(opl3_slot *slot, Bit8u type)
+{
+ if (!slot->key)
+ {
+ slot->eg_gen = envelope_gen_num_attack;
+ OPL3_EnvelopeUpdateRate(slot);
+ if ((slot->eg_rate >> 2) == 0x0f)
+ {
+ slot->eg_gen = envelope_gen_num_decay;
+ OPL3_EnvelopeUpdateRate(slot);
+ slot->eg_rout = 0x00;
+ }
+ slot->pg_phase = 0x00;
+ }
+ slot->key |= type;
+}
+
+static void OPL3_EnvelopeKeyOff(opl3_slot *slot, Bit8u type)
+{
+ if (slot->key)
+ {
+ slot->key &= (~type);
+ if (!slot->key)
+ {
+ slot->eg_gen = envelope_gen_num_release;
+ OPL3_EnvelopeUpdateRate(slot);
+ }
+ }
+}
+
+/*
+ * Phase Generator
+ */
+
+static void OPL3_PhaseGenerate(opl3_slot *slot)
+{
+ Bit16u f_num;
+ Bit32u basefreq;
+
+ f_num = slot->channel->f_num;
+ if (slot->reg_vib)
+ {
+ Bit8s range;
+ Bit8u vibpos;
+
+ range = (f_num >> 7) & 7;
+ vibpos = slot->chip->vibpos;
+
+ if (!(vibpos & 3))
+ {
+ range = 0;
+ }
+ else if (vibpos & 1)
+ {
+ range >>= 1;
+ }
+ range >>= slot->chip->vibshift;
+
+ if (vibpos & 4)
+ {
+ range = -range;
+ }
+ f_num += range;
+ }
+ basefreq = (f_num << slot->channel->block) >> 1;
+ slot->pg_phase += (basefreq * mt[slot->reg_mult]) >> 1;
+}
+
+/*
+ * Noise Generator
+ */
+
+static void OPL3_NoiseGenerate(opl3_chip *chip)
+{
+ if (chip->noise & 0x01)
+ {
+ chip->noise ^= 0x800302;
+ }
+ chip->noise >>= 1;
+}
+
+/*
+ * Slot
+ */
+
+static void OPL3_SlotWrite20(opl3_slot *slot, Bit8u data)
+{
+ if ((data >> 7) & 0x01)
+ {
+ slot->trem = &slot->chip->tremolo;
+ }
+ else
+ {
+ slot->trem = (Bit8u*)&slot->chip->zeromod;
+ }
+ slot->reg_vib = (data >> 6) & 0x01;
+ slot->reg_type = (data >> 5) & 0x01;
+ slot->reg_ksr = (data >> 4) & 0x01;
+ slot->reg_mult = data & 0x0f;
+ OPL3_EnvelopeUpdateRate(slot);
+}
+
+static void OPL3_SlotWrite40(opl3_slot *slot, Bit8u data)
+{
+ slot->reg_ksl = (data >> 6) & 0x03;
+ slot->reg_tl = data & 0x3f;
+ OPL3_EnvelopeUpdateKSL(slot);
+}
+
+static void OPL3_SlotWrite60(opl3_slot *slot, Bit8u data)
+{
+ slot->reg_ar = (data >> 4) & 0x0f;
+ slot->reg_dr = data & 0x0f;
+ OPL3_EnvelopeUpdateRate(slot);
+}
+
+static void OPL3_SlotWrite80(opl3_slot *slot, Bit8u data)
+{
+ slot->reg_sl = (data >> 4) & 0x0f;
+ if (slot->reg_sl == 0x0f)
+ {
+ slot->reg_sl = 0x1f;
+ }
+ slot->reg_rr = data & 0x0f;
+ OPL3_EnvelopeUpdateRate(slot);
+}
+
+static void OPL3_SlotWriteE0(opl3_slot *slot, Bit8u data)
+{
+ slot->reg_wf = data & 0x07;
+ if (slot->chip->newm == 0x00)
+ {
+ slot->reg_wf &= 0x03;
+ }
+
+ switch (slot->reg_wf)
+ {
+ case 1:
+ case 4:
+ case 5:
+ slot->maskzero = 0x200;
+ break;
+ case 3:
+ slot->maskzero = 0x100;
+ break;
+ default:
+ slot->maskzero = 0;
+ break;
+ }
+
+ switch (slot->reg_wf)
+ {
+ case 4:
+ slot->signpos = (31-8); /* sigext of (phase & 0x100) */
+ break;
+ case 0:
+ case 6:
+ case 7:
+ slot->signpos = (31-9); /* sigext of (phase & 0x200) */
+ break;
+ default:
+ slot->signpos = (31-16); /* set "neg" to zero */
+ break;
+ }
+
+ switch (slot->reg_wf)
+ {
+ case 4:
+ case 5:
+ slot->phaseshift = 1;
+ break;
+ case 6:
+ slot->phaseshift = 16; /* set phase to zero and flag for non-sin wave */
+ break;
+ case 7:
+ slot->phaseshift = 32; /* no shift (work by mod 32), but flag for non-sin wave */
+ break;
+ default:
+ slot->phaseshift = 0;
+ break;
+ }
+}
+
+static void OPL3_SlotGeneratePhase(opl3_slot *slot, Bit16u phase)
+{
+ Bit32u neg, level;
+ Bit8u phaseshift;
+
+ /* Fast paths for mute segments */
+ if (phase & slot->maskzero)
+ {
+ slot->out = 0;
+ return;
+ }
+
+ neg = (Bit32s)((Bit32u)phase << slot->signpos) >> 31;
+ phaseshift = slot->phaseshift;
+ level = slot->eg_out;
+
+ phase <<= phaseshift;
+ if (phaseshift <= 1)
+ {
+ level += logsinrom[phase & 0x1ff];
+ }
+ else
+ {
+ level += ((phase ^ neg) & 0x3ff) << 3;
+ }
+ slot->out = exprom[level & 0xff] >> (level >> 8) ^ neg;
+}
+
+static void OPL3_SlotGenerate(opl3_slot *slot)
+{
+ OPL3_SlotGeneratePhase(slot, (Bit16u)(slot->pg_phase >> 9) + *slot->mod);
+}
+
+static void OPL3_SlotGenerateZM(opl3_slot *slot)
+{
+ OPL3_SlotGeneratePhase(slot, (Bit16u)(slot->pg_phase >> 9));
+}
+
+static void OPL3_SlotCalcFB(opl3_slot *slot)
+{
+ if (slot->channel->fb != 0x00)
+ {
+ slot->fbmod = (slot->prout + slot->out) >> (0x09 - slot->channel->fb);
+ }
+ else
+ {
+ slot->fbmod = 0;
+ }
+ slot->prout = slot->out;
+}
+
+/*
+ * Channel
+ */
+
+static void OPL3_ChannelSetupAlg(opl3_channel *channel);
+
+static void OPL3_ChannelUpdateRhythm(opl3_chip *chip, Bit8u data)
+{
+ opl3_channel *channel6;
+ opl3_channel *channel7;
+ opl3_channel *channel8;
+ Bit8u chnum;
+
+ chip->rhy = data & 0x3f;
+ if (chip->rhy & 0x20)
+ {
+ channel6 = &chip->channel[6];
+ channel7 = &chip->channel[7];
+ channel8 = &chip->channel[8];
+ channel6->out[0] = &channel6->slots[1]->out;
+ channel6->out[1] = &channel6->slots[1]->out;
+ channel6->out[2] = &chip->zeromod;
+ channel6->out[3] = &chip->zeromod;
+ channel7->out[0] = &channel7->slots[0]->out;
+ channel7->out[1] = &channel7->slots[0]->out;
+ channel7->out[2] = &channel7->slots[1]->out;
+ channel7->out[3] = &channel7->slots[1]->out;
+ channel8->out[0] = &channel8->slots[0]->out;
+ channel8->out[1] = &channel8->slots[0]->out;
+ channel8->out[2] = &channel8->slots[1]->out;
+ channel8->out[3] = &channel8->slots[1]->out;
+ for (chnum = 6; chnum < 9; chnum++)
+ {
+ chip->channel[chnum].chtype = ch_drum;
+ }
+ OPL3_ChannelSetupAlg(channel6);
+ /*hh*/
+ if (chip->rhy & 0x01)
+ {
+ OPL3_EnvelopeKeyOn(channel7->slots[0], egk_drum);
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOff(channel7->slots[0], egk_drum);
+ }
+ /*tc*/
+ if (chip->rhy & 0x02)
+ {
+ OPL3_EnvelopeKeyOn(channel8->slots[1], egk_drum);
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOff(channel8->slots[1], egk_drum);
+ }
+ /*tom*/
+ if (chip->rhy & 0x04)
+ {
+ OPL3_EnvelopeKeyOn(channel8->slots[0], egk_drum);
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOff(channel8->slots[0], egk_drum);
+ }
+ /*sd*/
+ if (chip->rhy & 0x08)
+ {
+ OPL3_EnvelopeKeyOn(channel7->slots[1], egk_drum);
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOff(channel7->slots[1], egk_drum);
+ }
+ /*bd*/
+ if (chip->rhy & 0x10)
+ {
+ OPL3_EnvelopeKeyOn(channel6->slots[0], egk_drum);
+ OPL3_EnvelopeKeyOn(channel6->slots[1], egk_drum);
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOff(channel6->slots[0], egk_drum);
+ OPL3_EnvelopeKeyOff(channel6->slots[1], egk_drum);
+ }
+ }
+ else
+ {
+ for (chnum = 6; chnum < 9; chnum++)
+ {
+ chip->channel[chnum].chtype = ch_2op;
+ OPL3_ChannelSetupAlg(&chip->channel[chnum]);
+ OPL3_EnvelopeKeyOff(chip->channel[chnum].slots[0], egk_drum);
+ OPL3_EnvelopeKeyOff(chip->channel[chnum].slots[1], egk_drum);
+ }
+ }
+}
+
+static void OPL3_ChannelWriteA0(opl3_channel *channel, Bit8u data)
+{
+ if (channel->chip->newm && channel->chtype == ch_4op2)
+ {
+ return;
+ }
+ channel->f_num = (channel->f_num & 0x300) | data;
+ channel->ksv = (channel->block << 1)
+ | ((channel->f_num >> (0x09 - channel->chip->nts)) & 0x01);
+ OPL3_EnvelopeUpdateKSL(channel->slots[0]);
+ OPL3_EnvelopeUpdateKSL(channel->slots[1]);
+ OPL3_EnvelopeUpdateRate(channel->slots[0]);
+ OPL3_EnvelopeUpdateRate(channel->slots[1]);
+ if (channel->chip->newm && channel->chtype == ch_4op)
+ {
+ channel->pair->f_num = channel->f_num;
+ channel->pair->ksv = channel->ksv;
+ OPL3_EnvelopeUpdateKSL(channel->pair->slots[0]);
+ OPL3_EnvelopeUpdateKSL(channel->pair->slots[1]);
+ OPL3_EnvelopeUpdateRate(channel->pair->slots[0]);
+ OPL3_EnvelopeUpdateRate(channel->pair->slots[1]);
+ }
+}
+
+static void OPL3_ChannelWriteB0(opl3_channel *channel, Bit8u data)
+{
+ if (channel->chip->newm && channel->chtype == ch_4op2)
+ {
+ return;
+ }
+ channel->f_num = (channel->f_num & 0xff) | ((data & 0x03) << 8);
+ channel->block = (data >> 2) & 0x07;
+ channel->ksv = (channel->block << 1)
+ | ((channel->f_num >> (0x09 - channel->chip->nts)) & 0x01);
+ OPL3_EnvelopeUpdateKSL(channel->slots[0]);
+ OPL3_EnvelopeUpdateKSL(channel->slots[1]);
+ OPL3_EnvelopeUpdateRate(channel->slots[0]);
+ OPL3_EnvelopeUpdateRate(channel->slots[1]);
+ if (channel->chip->newm && channel->chtype == ch_4op)
+ {
+ channel->pair->f_num = channel->f_num;
+ channel->pair->block = channel->block;
+ channel->pair->ksv = channel->ksv;
+ OPL3_EnvelopeUpdateKSL(channel->pair->slots[0]);
+ OPL3_EnvelopeUpdateKSL(channel->pair->slots[1]);
+ OPL3_EnvelopeUpdateRate(channel->pair->slots[0]);
+ OPL3_EnvelopeUpdateRate(channel->pair->slots[1]);
+ }
+}
+
+static void OPL3_ChannelSetupAlg(opl3_channel *channel)
+{
+ if (channel->chtype == ch_drum)
+ {
+ switch (channel->alg & 0x01)
+ {
+ case 0x00:
+ channel->slots[0]->mod = &channel->slots[0]->fbmod;
+ channel->slots[1]->mod = &channel->slots[0]->out;
+ break;
+ case 0x01:
+ channel->slots[0]->mod = &channel->slots[0]->fbmod;
+ channel->slots[1]->mod = &channel->chip->zeromod;
+ break;
+ }
+ return;
+ }
+ if (channel->alg & 0x08)
+ {
+ return;
+ }
+ if (channel->alg & 0x04)
+ {
+ channel->pair->out[0] = &channel->chip->zeromod;
+ channel->pair->out[1] = &channel->chip->zeromod;
+ channel->pair->out[2] = &channel->chip->zeromod;
+ channel->pair->out[3] = &channel->chip->zeromod;
+ switch (channel->alg & 0x03)
+ {
+ case 0x00:
+ channel->pair->slots[0]->mod = &channel->pair->slots[0]->fbmod;
+ channel->pair->slots[1]->mod = &channel->pair->slots[0]->out;
+ channel->slots[0]->mod = &channel->pair->slots[1]->out;
+ channel->slots[1]->mod = &channel->slots[0]->out;
+ channel->out[0] = &channel->slots[1]->out;
+ channel->out[1] = &channel->chip->zeromod;
+ channel->out[2] = &channel->chip->zeromod;
+ channel->out[3] = &channel->chip->zeromod;
+ break;
+ case 0x01:
+ channel->pair->slots[0]->mod = &channel->pair->slots[0]->fbmod;
+ channel->pair->slots[1]->mod = &channel->pair->slots[0]->out;
+ channel->slots[0]->mod = &channel->chip->zeromod;
+ channel->slots[1]->mod = &channel->slots[0]->out;
+ channel->out[0] = &channel->pair->slots[1]->out;
+ channel->out[1] = &channel->slots[1]->out;
+ channel->out[2] = &channel->chip->zeromod;
+ channel->out[3] = &channel->chip->zeromod;
+ break;
+ case 0x02:
+ channel->pair->slots[0]->mod = &channel->pair->slots[0]->fbmod;
+ channel->pair->slots[1]->mod = &channel->chip->zeromod;
+ channel->slots[0]->mod = &channel->pair->slots[1]->out;
+ channel->slots[1]->mod = &channel->slots[0]->out;
+ channel->out[0] = &channel->pair->slots[0]->out;
+ channel->out[1] = &channel->slots[1]->out;
+ channel->out[2] = &channel->chip->zeromod;
+ channel->out[3] = &channel->chip->zeromod;
+ break;
+ case 0x03:
+ channel->pair->slots[0]->mod = &channel->pair->slots[0]->fbmod;
+ channel->pair->slots[1]->mod = &channel->chip->zeromod;
+ channel->slots[0]->mod = &channel->pair->slots[1]->out;
+ channel->slots[1]->mod = &channel->chip->zeromod;
+ channel->out[0] = &channel->pair->slots[0]->out;
+ channel->out[1] = &channel->slots[0]->out;
+ channel->out[2] = &channel->slots[1]->out;
+ channel->out[3] = &channel->chip->zeromod;
+ break;
+ }
+ }
+ else
+ {
+ switch (channel->alg & 0x01)
+ {
+ case 0x00:
+ channel->slots[0]->mod = &channel->slots[0]->fbmod;
+ channel->slots[1]->mod = &channel->slots[0]->out;
+ channel->out[0] = &channel->slots[1]->out;
+ channel->out[1] = &channel->chip->zeromod;
+ channel->out[2] = &channel->chip->zeromod;
+ channel->out[3] = &channel->chip->zeromod;
+ break;
+ case 0x01:
+ channel->slots[0]->mod = &channel->slots[0]->fbmod;
+ channel->slots[1]->mod = &channel->chip->zeromod;
+ channel->out[0] = &channel->slots[0]->out;
+ channel->out[1] = &channel->slots[1]->out;
+ channel->out[2] = &channel->chip->zeromod;
+ channel->out[3] = &channel->chip->zeromod;
+ break;
+ }
+ }
+}
+
+static void OPL3_ChannelWriteC0(opl3_channel *channel, Bit8u data)
+{
+ channel->fb = (data & 0x0e) >> 1;
+ channel->con = data & 0x01;
+ channel->alg = channel->con;
+ if (channel->chip->newm)
+ {
+ if (channel->chtype == ch_4op)
+ {
+ channel->pair->alg = 0x04 | (channel->con << 1) | (channel->pair->con);
+ channel->alg = 0x08;
+ OPL3_ChannelSetupAlg(channel->pair);
+ }
+ else if (channel->chtype == ch_4op2)
+ {
+ channel->alg = 0x04 | (channel->pair->con << 1) | (channel->con);
+ channel->pair->alg = 0x08;
+ OPL3_ChannelSetupAlg(channel);
+ }
+ else
+ {
+ OPL3_ChannelSetupAlg(channel);
+ }
+ }
+ else
+ {
+ OPL3_ChannelSetupAlg(channel);
+ }
+ if (channel->chip->newm)
+ {
+ channel->cha = ((data >> 4) & 0x01) ? ~0 : 0;
+ channel->chb = ((data >> 5) & 0x01) ? ~0 : 0;
+ }
+ else
+ {
+ channel->cha = channel->chb = ~0;
+ }
+}
+
+static void OPL3_ChannelKeyOn(opl3_channel *channel)
+{
+ if (channel->chip->newm)
+ {
+ if (channel->chtype == ch_4op)
+ {
+ OPL3_EnvelopeKeyOn(channel->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOn(channel->slots[1], egk_norm);
+ OPL3_EnvelopeKeyOn(channel->pair->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOn(channel->pair->slots[1], egk_norm);
+ }
+ else if (channel->chtype == ch_2op || channel->chtype == ch_drum)
+ {
+ OPL3_EnvelopeKeyOn(channel->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOn(channel->slots[1], egk_norm);
+ }
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOn(channel->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOn(channel->slots[1], egk_norm);
+ }
+}
+
+static void OPL3_ChannelKeyOff(opl3_channel *channel)
+{
+ if (channel->chip->newm)
+ {
+ if (channel->chtype == ch_4op)
+ {
+ OPL3_EnvelopeKeyOff(channel->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOff(channel->slots[1], egk_norm);
+ OPL3_EnvelopeKeyOff(channel->pair->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOff(channel->pair->slots[1], egk_norm);
+ }
+ else if (channel->chtype == ch_2op || channel->chtype == ch_drum)
+ {
+ OPL3_EnvelopeKeyOff(channel->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOff(channel->slots[1], egk_norm);
+ }
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOff(channel->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOff(channel->slots[1], egk_norm);
+ }
+}
+
+static void OPL3_ChannelSet4Op(opl3_chip *chip, Bit8u data)
+{
+ Bit8u bit;
+ Bit8u chnum;
+ for (bit = 0; bit < 6; bit++)
+ {
+ chnum = bit;
+ if (bit >= 3)
+ {
+ chnum += 9 - 3;
+ }
+ if ((data >> bit) & 0x01)
+ {
+ chip->channel[chnum].chtype = ch_4op;
+ chip->channel[chnum + 3].chtype = ch_4op2;
+ }
+ else
+ {
+ chip->channel[chnum].chtype = ch_2op;
+ chip->channel[chnum + 3].chtype = ch_2op;
+ }
+ }
+}
+
+static Bit16s OPL3_ClipSample(Bit32s sample)
+{
+ if (sample > 32767)
+ {
+ sample = 32767;
+ }
+ else if (sample < -32768)
+ {
+ sample = -32768;
+ }
+ return (Bit16s)sample;
+}
+
+static void OPL3_GenerateRhythm1(opl3_chip *chip)
+{
+ opl3_channel *channel6;
+ opl3_channel *channel7;
+ opl3_channel *channel8;
+ Bit16u phase14;
+ Bit16u phase17;
+ Bit16u phase;
+ Bit16u phasebit;
+
+ channel6 = &chip->channel[6];
+ channel7 = &chip->channel[7];
+ channel8 = &chip->channel[8];
+ OPL3_SlotGenerate(channel6->slots[0]);
+ phase14 = (channel7->slots[0]->pg_phase >> 9) & 0x3ff;
+ phase17 = (channel8->slots[1]->pg_phase >> 9) & 0x3ff;
+ phase = 0x00;
+ /*hh tc phase bit*/
+ phasebit = ((phase14 & 0x08) | (((phase14 >> 5) ^ phase14) & 0x04)
+ | (((phase17 >> 2) ^ phase17) & 0x08)) ? 0x01 : 0x00;
+ /*hh*/
+ phase = (phasebit << 9)
+ | (0x34 << ((phasebit ^ (chip->noise & 0x01)) << 1));
+ OPL3_SlotGeneratePhase(channel7->slots[0], phase);
+ /*tt*/
+ OPL3_SlotGenerateZM(channel8->slots[0]);
+}
+
+static void OPL3_GenerateRhythm2(opl3_chip *chip)
+{
+ opl3_channel *channel6;
+ opl3_channel *channel7;
+ opl3_channel *channel8;
+ Bit16u phase14;
+ Bit16u phase17;
+ Bit16u phase;
+ Bit16u phasebit;
+
+ channel6 = &chip->channel[6];
+ channel7 = &chip->channel[7];
+ channel8 = &chip->channel[8];
+ OPL3_SlotGenerate(channel6->slots[1]);
+ phase14 = (channel7->slots[0]->pg_phase >> 9) & 0x3ff;
+ phase17 = (channel8->slots[1]->pg_phase >> 9) & 0x3ff;
+ phase = 0x00;
+ /*hh tc phase bit*/
+ phasebit = ((phase14 & 0x08) | (((phase14 >> 5) ^ phase14) & 0x04)
+ | (((phase17 >> 2) ^ phase17) & 0x08)) ? 0x01 : 0x00;
+ /*sd*/
+ phase = (0x100 << ((phase14 >> 8) & 0x01)) ^ ((chip->noise & 0x01) << 8);
+ OPL3_SlotGeneratePhase(channel7->slots[1], phase);
+ /*tc*/
+ phase = 0x100 | (phasebit << 9);
+ OPL3_SlotGeneratePhase(channel8->slots[1], phase);
+}
+
+void OPL3v17_Generate(opl3_chip *chip, Bit16s *buf)
+{
+ Bit8u ii;
+ Bit8u jj;
+ Bit16s accm;
+
+ buf[1] = OPL3_ClipSample(chip->mixbuff[1]);
+
+ for (ii = 0; ii < 12; ii++)
+ {
+ OPL3_SlotCalcFB(&chip->chipslot[ii]);
+ OPL3_PhaseGenerate(&chip->chipslot[ii]);
+ OPL3_EnvelopeCalc(&chip->chipslot[ii]);
+ OPL3_SlotGenerate(&chip->chipslot[ii]);
+ }
+
+ for (ii = 12; ii < 15; ii++)
+ {
+ OPL3_SlotCalcFB(&chip->chipslot[ii]);
+ OPL3_PhaseGenerate(&chip->chipslot[ii]);
+ OPL3_EnvelopeCalc(&chip->chipslot[ii]);
+ }
+
+ if (chip->rhy & 0x20)
+ {
+ OPL3_GenerateRhythm1(chip);
+ }
+ else
+ {
+ OPL3_SlotGenerate(&chip->chipslot[12]);
+ OPL3_SlotGenerate(&chip->chipslot[13]);
+ OPL3_SlotGenerate(&chip->chipslot[14]);
+ }
+
+ chip->mixbuff[0] = 0;
+ for (ii = 0; ii < 18; ii++)
+ {
+ accm = 0;
+ for (jj = 0; jj < 4; jj++)
+ {
+ accm += *chip->channel[ii].out[jj];
+ }
+ chip->mixbuff[0] += (Bit16s)(accm & chip->channel[ii].cha);
+ }
+
+ for (ii = 15; ii < 18; ii++)
+ {
+ OPL3_SlotCalcFB(&chip->chipslot[ii]);
+ OPL3_PhaseGenerate(&chip->chipslot[ii]);
+ OPL3_EnvelopeCalc(&chip->chipslot[ii]);
+ }
+
+ if (chip->rhy & 0x20)
+ {
+ OPL3_GenerateRhythm2(chip);
+ }
+ else
+ {
+ OPL3_SlotGenerate(&chip->chipslot[15]);
+ OPL3_SlotGenerate(&chip->chipslot[16]);
+ OPL3_SlotGenerate(&chip->chipslot[17]);
+ }
+
+ buf[0] = OPL3_ClipSample(chip->mixbuff[0]);
+
+ for (ii = 18; ii < 33; ii++)
+ {
+ OPL3_SlotCalcFB(&chip->chipslot[ii]);
+ OPL3_PhaseGenerate(&chip->chipslot[ii]);
+ OPL3_EnvelopeCalc(&chip->chipslot[ii]);
+ OPL3_SlotGenerate(&chip->chipslot[ii]);
+ }
+
+ chip->mixbuff[1] = 0;
+ for (ii = 0; ii < 18; ii++)
+ {
+ accm = 0;
+ for (jj = 0; jj < 4; jj++)
+ {
+ accm += *chip->channel[ii].out[jj];
+ }
+ chip->mixbuff[1] += (Bit16s)(accm & chip->channel[ii].chb);
+ }
+
+ for (ii = 33; ii < 36; ii++)
+ {
+ OPL3_SlotCalcFB(&chip->chipslot[ii]);
+ OPL3_PhaseGenerate(&chip->chipslot[ii]);
+ OPL3_EnvelopeCalc(&chip->chipslot[ii]);
+ OPL3_SlotGenerate(&chip->chipslot[ii]);
+ }
+
+ OPL3_NoiseGenerate(chip);
+
+ if ((chip->timer & 0x3f) == 0x3f)
+ {
+ chip->tremolopos = (chip->tremolopos + 1) % 210;
+ }
+ if (chip->tremolopos < 105)
+ {
+ chip->tremolo = chip->tremolopos >> chip->tremoloshift;
+ }
+ else
+ {
+ chip->tremolo = (210 - chip->tremolopos) >> chip->tremoloshift;
+ }
+
+ if ((chip->timer & 0x3ff) == 0x3ff)
+ {
+ chip->vibpos = (chip->vibpos + 1) & 7;
+ }
+
+ chip->timer++;
+
+ while (chip->writebuf[chip->writebuf_cur].time <= chip->writebuf_samplecnt)
+ {
+ if (!(chip->writebuf[chip->writebuf_cur].reg & 0x200))
+ {
+ break;
+ }
+ chip->writebuf[chip->writebuf_cur].reg &= 0x1ff;
+ OPL3v17_WriteReg(chip, chip->writebuf[chip->writebuf_cur].reg,
+ chip->writebuf[chip->writebuf_cur].data);
+ chip->writebuf_cur = (chip->writebuf_cur + 1) % OPL_WRITEBUF_SIZE;
+ }
+ chip->writebuf_samplecnt++;
+}
+
+void OPL3v17_GenerateResampled(opl3_chip *chip, Bit16s *buf)
+{
+ while (chip->samplecnt >= chip->rateratio)
+ {
+ chip->oldsamples[0] = chip->samples[0];
+ chip->oldsamples[1] = chip->samples[1];
+ OPL3v17_Generate(chip, chip->samples);
+ chip->samplecnt -= chip->rateratio;
+ }
+ buf[0] = (Bit16s)((chip->oldsamples[0] * (chip->rateratio - chip->samplecnt)
+ + chip->samples[0] * chip->samplecnt) / chip->rateratio);
+ buf[1] = (Bit16s)((chip->oldsamples[1] * (chip->rateratio - chip->samplecnt)
+ + chip->samples[1] * chip->samplecnt) / chip->rateratio);
+ chip->samplecnt += 1 << RSM_FRAC;
+}
+
+void OPL3v17_Reset(opl3_chip *chip, Bit32u samplerate)
+{
+ Bit8u slotnum;
+ Bit8u channum;
+
+ memset(chip, 0, sizeof(opl3_chip));
+ for (slotnum = 0; slotnum < 36; slotnum++)
+ {
+ chip->chipslot[slotnum].chip = chip;
+ chip->chipslot[slotnum].mod = &chip->zeromod;
+ chip->chipslot[slotnum].eg_rout = 0x1ff;
+ chip->chipslot[slotnum].eg_out = 0x1ff << 3;
+ chip->chipslot[slotnum].eg_gen = envelope_gen_num_off;
+ chip->chipslot[slotnum].trem = (Bit8u*)&chip->zeromod;
+ chip->chipslot[slotnum].signpos = (31-9); /* for wf=0 need use sigext of (phase & 0x200) */
+ }
+ for (channum = 0; channum < 18; channum++)
+ {
+ chip->channel[channum].slots[0] = &chip->chipslot[ch_slot[channum]];
+ chip->channel[channum].slots[1] = &chip->chipslot[ch_slot[channum] + 3];
+ chip->chipslot[ch_slot[channum]].channel = &chip->channel[channum];
+ chip->chipslot[ch_slot[channum] + 3].channel = &chip->channel[channum];
+ if ((channum % 9) < 3)
+ {
+ chip->channel[channum].pair = &chip->channel[channum + 3];
+ }
+ else if ((channum % 9) < 6)
+ {
+ chip->channel[channum].pair = &chip->channel[channum - 3];
+ }
+ chip->channel[channum].chip = chip;
+ chip->channel[channum].out[0] = &chip->zeromod;
+ chip->channel[channum].out[1] = &chip->zeromod;
+ chip->channel[channum].out[2] = &chip->zeromod;
+ chip->channel[channum].out[3] = &chip->zeromod;
+ chip->channel[channum].chtype = ch_2op;
+ chip->channel[channum].cha = ~0;
+ chip->channel[channum].chb = ~0;
+ OPL3_ChannelSetupAlg(&chip->channel[channum]);
+ }
+ chip->noise = 0x306600;
+ chip->rateratio = (samplerate << RSM_FRAC) / 49716;
+ chip->tremoloshift = 4;
+ chip->vibshift = 1;
+}
+
+void OPL3v17_WriteReg(opl3_chip *chip, Bit16u reg, Bit8u v)
+{
+ Bit8u high = (reg >> 8) & 0x01;
+ Bit8u regm = reg & 0xff;
+ switch (regm & 0xf0)
+ {
+ case 0x00:
+ if (high)
+ {
+ switch (regm & 0x0f)
+ {
+ case 0x04:
+ OPL3_ChannelSet4Op(chip, v);
+ break;
+ case 0x05:
+ chip->newm = v & 0x01;
+ break;
+ }
+ }
+ else
+ {
+ switch (regm & 0x0f)
+ {
+ case 0x08:
+ chip->nts = (v >> 6) & 0x01;
+ break;
+ }
+ }
+ break;
+ case 0x20:
+ case 0x30:
+ if (ad_slot[regm & 0x1f] >= 0)
+ {
+ OPL3_SlotWrite20(&chip->chipslot[18 * high + ad_slot[regm & 0x1f]], v);
+ }
+ break;
+ case 0x40:
+ case 0x50:
+ if (ad_slot[regm & 0x1f] >= 0)
+ {
+ OPL3_SlotWrite40(&chip->chipslot[18 * high + ad_slot[regm & 0x1f]], v);
+ }
+ break;
+ case 0x60:
+ case 0x70:
+ if (ad_slot[regm & 0x1f] >= 0)
+ {
+ OPL3_SlotWrite60(&chip->chipslot[18 * high + ad_slot[regm & 0x1f]], v);
+ }
+ break;
+ case 0x80:
+ case 0x90:
+ if (ad_slot[regm & 0x1f] >= 0)
+ {
+ OPL3_SlotWrite80(&chip->chipslot[18 * high + ad_slot[regm & 0x1f]], v);
+ }
+ break;
+ case 0xe0:
+ case 0xf0:
+ if (ad_slot[regm & 0x1f] >= 0)
+ {
+ OPL3_SlotWriteE0(&chip->chipslot[18 * high + ad_slot[regm & 0x1f]], v);
+ }
+ break;
+ case 0xa0:
+ if ((regm & 0x0f) < 9)
+ {
+ OPL3_ChannelWriteA0(&chip->channel[9 * high + (regm & 0x0f)], v);
+ }
+ break;
+ case 0xb0:
+ if (regm == 0xbd && !high)
+ {
+ chip->tremoloshift = (((v >> 7) ^ 1) << 1) + 2;
+ chip->vibshift = ((v >> 6) & 0x01) ^ 1;
+ OPL3_ChannelUpdateRhythm(chip, v);
+ }
+ else if ((regm & 0x0f) < 9)
+ {
+ OPL3_ChannelWriteB0(&chip->channel[9 * high + (regm & 0x0f)], v);
+ if (v & 0x20)
+ {
+ OPL3_ChannelKeyOn(&chip->channel[9 * high + (regm & 0x0f)]);
+ }
+ else
+ {
+ OPL3_ChannelKeyOff(&chip->channel[9 * high + (regm & 0x0f)]);
+ }
+ }
+ break;
+ case 0xc0:
+ if ((regm & 0x0f) < 9)
+ {
+ OPL3_ChannelWriteC0(&chip->channel[9 * high + (regm & 0x0f)], v);
+ }
+ break;
+ }
+}
+
+void OPL3v17_WriteRegBuffered(opl3_chip *chip, Bit16u reg, Bit8u v)
+{
+ Bit64u time1, time2;
+
+ if (chip->writebuf[chip->writebuf_last].reg & 0x200)
+ {
+ OPL3v17_WriteReg(chip, chip->writebuf[chip->writebuf_last].reg & 0x1ff,
+ chip->writebuf[chip->writebuf_last].data);
+
+ chip->writebuf_cur = (chip->writebuf_last + 1) % OPL_WRITEBUF_SIZE;
+ chip->writebuf_samplecnt = chip->writebuf[chip->writebuf_last].time;
+ }
+
+ chip->writebuf[chip->writebuf_last].reg = reg | 0x200;
+ chip->writebuf[chip->writebuf_last].data = v;
+ time1 = chip->writebuf_lasttime + OPL_WRITEBUF_DELAY;
+ time2 = chip->writebuf_samplecnt;
+
+ if (time1 < time2)
+ {
+ time1 = time2;
+ }
+
+ chip->writebuf[chip->writebuf_last].time = time1;
+ chip->writebuf_lasttime = time1;
+ chip->writebuf_last = (chip->writebuf_last + 1) % OPL_WRITEBUF_SIZE;
+}
+
+void OPL3v17_GenerateStream(opl3_chip *chip, Bit16s *sndptr, Bit32u numsamples)
+{
+ Bit32u i;
+
+ for(i = 0; i < numsamples; i++)
+ {
+ OPL3v17_GenerateResampled(chip, sndptr);
+ sndptr += 2;
+ }
+}
+
+#define OPL3_MIN(A, B) (((A) > (B)) ? (B) : (A))
+#define OPL3_MAX(A, B) (((A) < (B)) ? (B) : (A))
+#define OPL3_CLAMP(V, MIN, MAX) OPL3_MAX(OPL3_MIN(V, MAX), MIN)
+
+void OPL3v17_GenerateStreamMix(opl3_chip *chip, Bit16s *sndptr, Bit32u numsamples)
+{
+ Bit32u i;
+ Bit16s sample[2];
+ Bit32s mix[2];
+
+ for(i = 0; i < numsamples; i++)
+ {
+ OPL3v17_GenerateResampled(chip, sample);
+ mix[0] = sndptr[0] + sample[0];
+ mix[1] = sndptr[1] + sample[1];
+ sndptr[0] = OPL3_CLAMP(mix[0], INT16_MIN, INT16_MAX);
+ sndptr[1] = OPL3_CLAMP(mix[1], INT16_MIN, INT16_MAX);
+ sndptr += 2;
+ }
+}
+
diff --git a/src/chips/nuked/nukedopl3_174.h b/src/chips/nuked/nukedopl3_174.h
new file mode 100644
index 0000000..43e4a6e
--- /dev/null
+++ b/src/chips/nuked/nukedopl3_174.h
@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 2013-2016 Alexey Khokholov (Nuke.YKT)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Nuked OPL3 emulator.
+ * Thanks:
+ * MAME Development Team(Jarek Burczynski, Tatsuyuki Satoh):
+ * Feedback and Rhythm part calculation information.
+ * forums.submarine.org.uk(carbon14, opl3):
+ * Tremolo and phase generator calculation information.
+ * OPLx decapsulated(Matthew Gambrell, Olli Niemitalo):
+ * OPL2 ROMs.
+ *
+ * version: 1.7.4
+ */
+
+#ifndef OPL_OPL3_H
+#define OPL_OPL3_H
+
+#include <inttypes.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define OPL_WRITEBUF_SIZE 1024
+#define OPL_WRITEBUF_DELAY 2
+
+typedef uintptr_t Bitu;
+typedef intptr_t Bits;
+typedef uint64_t Bit64u;
+typedef int64_t Bit64s;
+typedef uint32_t Bit32u;
+typedef int32_t Bit32s;
+typedef uint16_t Bit16u;
+typedef int16_t Bit16s;
+typedef uint8_t Bit8u;
+typedef int8_t Bit8s;
+
+typedef struct _opl3_slot opl3_slot;
+typedef struct _opl3_channel opl3_channel;
+typedef struct _opl3_chip opl3_chip;
+
+struct _opl3_slot {
+ opl3_channel *channel;
+ opl3_chip *chip;
+ Bit16s out;
+ Bit16s fbmod;
+ Bit16s *mod;
+ Bit16s prout;
+ Bit16s eg_rout;
+ Bit16s eg_out;
+ Bit8u eg_inc;
+ Bit8u eg_gen;
+ Bit8u eg_rate;
+ Bit8u eg_ksl;
+ Bit8u *trem;
+ Bit8u reg_vib;
+ Bit8u reg_type;
+ Bit8u reg_ksr;
+ Bit8u reg_mult;
+ Bit8u reg_ksl;
+ Bit8u reg_tl;
+ Bit8u reg_ar;
+ Bit8u reg_dr;
+ Bit8u reg_sl;
+ Bit8u reg_rr;
+ Bit8u reg_wf;
+ Bit8u key;
+ Bit32u pg_phase;
+ Bit32u timer;
+
+ Bit16u maskzero;
+ Bit8u signpos;
+ Bit8u phaseshift;
+};
+
+struct _opl3_channel {
+ opl3_slot *slots[2];
+ opl3_channel *pair;
+ opl3_chip *chip;
+ Bit16s *out[4];
+ Bit8u chtype;
+ Bit16u f_num;
+ Bit8u block;
+ Bit8u fb;
+ Bit8u con;
+ Bit8u alg;
+ Bit8u ksv;
+ Bit16u cha, chb;
+};
+
+typedef struct _opl3_writebuf {
+ Bit64u time;
+ Bit16u reg;
+ Bit8u data;
+} opl3_writebuf;
+
+struct _opl3_chip {
+ opl3_channel channel[18];
+ opl3_slot chipslot[36];
+ Bit16u timer;
+ Bit8u newm;
+ Bit8u nts;
+ Bit8u rhy;
+ Bit8u vibpos;
+ Bit8u vibshift;
+ Bit8u tremolo;
+ Bit8u tremolopos;
+ Bit8u tremoloshift;
+ Bit32u noise;
+ Bit16s zeromod;
+ Bit32s mixbuff[2];
+ /* OPL3L */
+ Bit32s rateratio;
+ Bit32s samplecnt;
+ Bit16s oldsamples[2];
+ Bit16s samples[2];
+
+ Bit64u writebuf_samplecnt;
+ Bit32u writebuf_cur;
+ Bit32u writebuf_last;
+ Bit64u writebuf_lasttime;
+ opl3_writebuf writebuf[OPL_WRITEBUF_SIZE];
+};
+
+void OPL3v17_Generate(opl3_chip *chip, Bit16s *buf);
+void OPL3v17_GenerateResampled(opl3_chip *chip, Bit16s *buf);
+void OPL3v17_Reset(opl3_chip *chip, Bit32u samplerate);
+void OPL3v17_WriteReg(opl3_chip *chip, Bit16u reg, Bit8u v);
+void OPL3v17_WriteRegBuffered(opl3_chip *chip, Bit16u reg, Bit8u v);
+void OPL3v17_GenerateStream(opl3_chip *chip, Bit16s *sndptr, Bit32u numsamples);
+void OPL3v17_GenerateStreamMix(opl3_chip *chip, Bit16s *sndptr, Bit32u numsamples);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/chips/nuked/old/nukedopl3.c b/src/chips/nuked/old/nukedopl3.c
new file mode 100644
index 0000000..6ae1eb7
--- /dev/null
+++ b/src/chips/nuked/old/nukedopl3.c
@@ -0,0 +1,1391 @@
+/*
+ * Copyright (C) 2013-2016 Alexey Khokholov (Nuke.YKT)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Nuked OPL3 emulator.
+ * Thanks:
+ * MAME Development Team(Jarek Burczynski, Tatsuyuki Satoh):
+ * Feedback and Rhythm part calculation information.
+ * forums.submarine.org.uk(carbon14, opl3):
+ * Tremolo and phase generator calculation information.
+ * OPLx decapsulated(Matthew Gambrell, Olli Niemitalo):
+ * OPL2 ROMs.
+ *
+ * version: 1.7.4
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "nukedopl3.h"
+
+#define RSM_FRAC 10
+
+/* Channel types */
+
+enum {
+ ch_2op = 0,
+ ch_4op = 1,
+ ch_4op2 = 2,
+ ch_drum = 3
+};
+
+/* Envelope key types */
+
+enum {
+ egk_norm = 0x01,
+ egk_drum = 0x02
+};
+
+
+/*
+ * logsin table
+ */
+
+static const Bit16u logsinrom[512] = {
+ 0x859, 0x6c3, 0x607, 0x58b, 0x52e, 0x4e4, 0x4a6, 0x471,
+ 0x443, 0x41a, 0x3f5, 0x3d3, 0x3b5, 0x398, 0x37e, 0x365,
+ 0x34e, 0x339, 0x324, 0x311, 0x2ff, 0x2ed, 0x2dc, 0x2cd,
+ 0x2bd, 0x2af, 0x2a0, 0x293, 0x286, 0x279, 0x26d, 0x261,
+ 0x256, 0x24b, 0x240, 0x236, 0x22c, 0x222, 0x218, 0x20f,
+ 0x206, 0x1fd, 0x1f5, 0x1ec, 0x1e4, 0x1dc, 0x1d4, 0x1cd,
+ 0x1c5, 0x1be, 0x1b7, 0x1b0, 0x1a9, 0x1a2, 0x19b, 0x195,
+ 0x18f, 0x188, 0x182, 0x17c, 0x177, 0x171, 0x16b, 0x166,
+ 0x160, 0x15b, 0x155, 0x150, 0x14b, 0x146, 0x141, 0x13c,
+ 0x137, 0x133, 0x12e, 0x129, 0x125, 0x121, 0x11c, 0x118,
+ 0x114, 0x10f, 0x10b, 0x107, 0x103, 0x0ff, 0x0fb, 0x0f8,
+ 0x0f4, 0x0f0, 0x0ec, 0x0e9, 0x0e5, 0x0e2, 0x0de, 0x0db,
+ 0x0d7, 0x0d4, 0x0d1, 0x0cd, 0x0ca, 0x0c7, 0x0c4, 0x0c1,
+ 0x0be, 0x0bb, 0x0b8, 0x0b5, 0x0b2, 0x0af, 0x0ac, 0x0a9,
+ 0x0a7, 0x0a4, 0x0a1, 0x09f, 0x09c, 0x099, 0x097, 0x094,
+ 0x092, 0x08f, 0x08d, 0x08a, 0x088, 0x086, 0x083, 0x081,
+ 0x07f, 0x07d, 0x07a, 0x078, 0x076, 0x074, 0x072, 0x070,
+ 0x06e, 0x06c, 0x06a, 0x068, 0x066, 0x064, 0x062, 0x060,
+ 0x05e, 0x05c, 0x05b, 0x059, 0x057, 0x055, 0x053, 0x052,
+ 0x050, 0x04e, 0x04d, 0x04b, 0x04a, 0x048, 0x046, 0x045,
+ 0x043, 0x042, 0x040, 0x03f, 0x03e, 0x03c, 0x03b, 0x039,
+ 0x038, 0x037, 0x035, 0x034, 0x033, 0x031, 0x030, 0x02f,
+ 0x02e, 0x02d, 0x02b, 0x02a, 0x029, 0x028, 0x027, 0x026,
+ 0x025, 0x024, 0x023, 0x022, 0x021, 0x020, 0x01f, 0x01e,
+ 0x01d, 0x01c, 0x01b, 0x01a, 0x019, 0x018, 0x017, 0x017,
+ 0x016, 0x015, 0x014, 0x014, 0x013, 0x012, 0x011, 0x011,
+ 0x010, 0x00f, 0x00f, 0x00e, 0x00d, 0x00d, 0x00c, 0x00c,
+ 0x00b, 0x00a, 0x00a, 0x009, 0x009, 0x008, 0x008, 0x007,
+ 0x007, 0x007, 0x006, 0x006, 0x005, 0x005, 0x005, 0x004,
+ 0x004, 0x004, 0x003, 0x003, 0x003, 0x002, 0x002, 0x002,
+ 0x002, 0x001, 0x001, 0x001, 0x001, 0x001, 0x001, 0x001,
+ 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000,
+ 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000,
+ 0x001, 0x001, 0x001, 0x001, 0x001, 0x001, 0x001, 0x002,
+ 0x002, 0x002, 0x002, 0x003, 0x003, 0x003, 0x004, 0x004,
+ 0x004, 0x005, 0x005, 0x005, 0x006, 0x006, 0x007, 0x007,
+ 0x007, 0x008, 0x008, 0x009, 0x009, 0x00a, 0x00a, 0x00b,
+ 0x00c, 0x00c, 0x00d, 0x00d, 0x00e, 0x00f, 0x00f, 0x010,
+ 0x011, 0x011, 0x012, 0x013, 0x014, 0x014, 0x015, 0x016,
+ 0x017, 0x017, 0x018, 0x019, 0x01a, 0x01b, 0x01c, 0x01d,
+ 0x01e, 0x01f, 0x020, 0x021, 0x022, 0x023, 0x024, 0x025,
+ 0x026, 0x027, 0x028, 0x029, 0x02a, 0x02b, 0x02d, 0x02e,
+ 0x02f, 0x030, 0x031, 0x033, 0x034, 0x035, 0x037, 0x038,
+ 0x039, 0x03b, 0x03c, 0x03e, 0x03f, 0x040, 0x042, 0x043,
+ 0x045, 0x046, 0x048, 0x04a, 0x04b, 0x04d, 0x04e, 0x050,
+ 0x052, 0x053, 0x055, 0x057, 0x059, 0x05b, 0x05c, 0x05e,
+ 0x060, 0x062, 0x064, 0x066, 0x068, 0x06a, 0x06c, 0x06e,
+ 0x070, 0x072, 0x074, 0x076, 0x078, 0x07a, 0x07d, 0x07f,
+ 0x081, 0x083, 0x086, 0x088, 0x08a, 0x08d, 0x08f, 0x092,
+ 0x094, 0x097, 0x099, 0x09c, 0x09f, 0x0a1, 0x0a4, 0x0a7,
+ 0x0a9, 0x0ac, 0x0af, 0x0b2, 0x0b5, 0x0b8, 0x0bb, 0x0be,
+ 0x0c1, 0x0c4, 0x0c7, 0x0ca, 0x0cd, 0x0d1, 0x0d4, 0x0d7,
+ 0x0db, 0x0de, 0x0e2, 0x0e5, 0x0e9, 0x0ec, 0x0f0, 0x0f4,
+ 0x0f8, 0x0fb, 0x0ff, 0x103, 0x107, 0x10b, 0x10f, 0x114,
+ 0x118, 0x11c, 0x121, 0x125, 0x129, 0x12e, 0x133, 0x137,
+ 0x13c, 0x141, 0x146, 0x14b, 0x150, 0x155, 0x15b, 0x160,
+ 0x166, 0x16b, 0x171, 0x177, 0x17c, 0x182, 0x188, 0x18f,
+ 0x195, 0x19b, 0x1a2, 0x1a9, 0x1b0, 0x1b7, 0x1be, 0x1c5,
+ 0x1cd, 0x1d4, 0x1dc, 0x1e4, 0x1ec, 0x1f5, 0x1fd, 0x206,
+ 0x20f, 0x218, 0x222, 0x22c, 0x236, 0x240, 0x24b, 0x256,
+ 0x261, 0x26d, 0x279, 0x286, 0x293, 0x2a0, 0x2af, 0x2bd,
+ 0x2cd, 0x2dc, 0x2ed, 0x2ff, 0x311, 0x324, 0x339, 0x34e,
+ 0x365, 0x37e, 0x398, 0x3b5, 0x3d3, 0x3f5, 0x41a, 0x443,
+ 0x471, 0x4a6, 0x4e4, 0x52e, 0x58b, 0x607, 0x6c3, 0x859
+};
+
+/*
+ * exp table
+ */
+
+static const Bit16u exprom[256] = {
+ 0xff4, 0xfea, 0xfde, 0xfd4, 0xfc8, 0xfbe, 0xfb4, 0xfa8,
+ 0xf9e, 0xf92, 0xf88, 0xf7e, 0xf72, 0xf68, 0xf5c, 0xf52,
+ 0xf48, 0xf3e, 0xf32, 0xf28, 0xf1e, 0xf14, 0xf08, 0xefe,
+ 0xef4, 0xeea, 0xee0, 0xed4, 0xeca, 0xec0, 0xeb6, 0xeac,
+ 0xea2, 0xe98, 0xe8e, 0xe84, 0xe7a, 0xe70, 0xe66, 0xe5c,
+ 0xe52, 0xe48, 0xe3e, 0xe34, 0xe2a, 0xe20, 0xe16, 0xe0c,
+ 0xe04, 0xdfa, 0xdf0, 0xde6, 0xddc, 0xdd2, 0xdca, 0xdc0,
+ 0xdb6, 0xdac, 0xda4, 0xd9a, 0xd90, 0xd88, 0xd7e, 0xd74,
+ 0xd6a, 0xd62, 0xd58, 0xd50, 0xd46, 0xd3c, 0xd34, 0xd2a,
+ 0xd22, 0xd18, 0xd10, 0xd06, 0xcfe, 0xcf4, 0xcec, 0xce2,
+ 0xcda, 0xcd0, 0xcc8, 0xcbe, 0xcb6, 0xcae, 0xca4, 0xc9c,
+ 0xc92, 0xc8a, 0xc82, 0xc78, 0xc70, 0xc68, 0xc60, 0xc56,
+ 0xc4e, 0xc46, 0xc3c, 0xc34, 0xc2c, 0xc24, 0xc1c, 0xc12,
+ 0xc0a, 0xc02, 0xbfa, 0xbf2, 0xbea, 0xbe0, 0xbd8, 0xbd0,
+ 0xbc8, 0xbc0, 0xbb8, 0xbb0, 0xba8, 0xba0, 0xb98, 0xb90,
+ 0xb88, 0xb80, 0xb78, 0xb70, 0xb68, 0xb60, 0xb58, 0xb50,
+ 0xb48, 0xb40, 0xb38, 0xb32, 0xb2a, 0xb22, 0xb1a, 0xb12,
+ 0xb0a, 0xb02, 0xafc, 0xaf4, 0xaec, 0xae4, 0xade, 0xad6,
+ 0xace, 0xac6, 0xac0, 0xab8, 0xab0, 0xaa8, 0xaa2, 0xa9a,
+ 0xa92, 0xa8c, 0xa84, 0xa7c, 0xa76, 0xa6e, 0xa68, 0xa60,
+ 0xa58, 0xa52, 0xa4a, 0xa44, 0xa3c, 0xa36, 0xa2e, 0xa28,
+ 0xa20, 0xa18, 0xa12, 0xa0c, 0xa04, 0x9fe, 0x9f6, 0x9f0,
+ 0x9e8, 0x9e2, 0x9da, 0x9d4, 0x9ce, 0x9c6, 0x9c0, 0x9b8,
+ 0x9b2, 0x9ac, 0x9a4, 0x99e, 0x998, 0x990, 0x98a, 0x984,
+ 0x97c, 0x976, 0x970, 0x96a, 0x962, 0x95c, 0x956, 0x950,
+ 0x948, 0x942, 0x93c, 0x936, 0x930, 0x928, 0x922, 0x91c,
+ 0x916, 0x910, 0x90a, 0x904, 0x8fc, 0x8f6, 0x8f0, 0x8ea,
+ 0x8e4, 0x8de, 0x8d8, 0x8d2, 0x8cc, 0x8c6, 0x8c0, 0x8ba,
+ 0x8b4, 0x8ae, 0x8a8, 0x8a2, 0x89c, 0x896, 0x890, 0x88a,
+ 0x884, 0x87e, 0x878, 0x872, 0x86c, 0x866, 0x860, 0x85a,
+ 0x854, 0x850, 0x84a, 0x844, 0x83e, 0x838, 0x832, 0x82c,
+ 0x828, 0x822, 0x81c, 0x816, 0x810, 0x80c, 0x806, 0x800
+};
+
+/*
+ * freq mult table multiplied by 2
+ *
+ * 1/2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 12, 12, 15, 15
+ */
+
+static const Bit8u mt[16] = {
+ 1, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 20, 24, 24, 30, 30
+};
+
+/*
+ * ksl table
+ */
+
+static const Bit8u kslrom[16] = {
+ 0, 32, 40, 45, 48, 51, 53, 55, 56, 58, 59, 60, 61, 62, 63, 64
+};
+
+static const Bit8u kslshift[4] = {
+ 8, 1, 2, 0
+};
+
+/*
+ * envelope generator constants
+ */
+
+static const Bit8u eg_incstep[3][4][8] = {
+ {
+ { 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, 0, 0, 0, 0, 0, 0, 0 }
+ },
+ {
+ { 0, 1, 0, 1, 0, 1, 0, 1 },
+ { 0, 1, 0, 1, 1, 1, 0, 1 },
+ { 0, 1, 1, 1, 0, 1, 1, 1 },
+ { 0, 1, 1, 1, 1, 1, 1, 1 }
+ },
+ {
+ { 1, 1, 1, 1, 1, 1, 1, 1 },
+ { 2, 2, 1, 1, 1, 1, 1, 1 },
+ { 2, 2, 1, 1, 2, 2, 1, 1 },
+ { 2, 2, 2, 2, 2, 2, 1, 1 }
+ }
+};
+
+static const Bit8u eg_incdesc[16] = {
+ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2
+};
+
+static const Bit8s eg_incsh[16] = {
+ 0, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, -1, -2
+};
+
+/*
+ * address decoding
+ */
+
+static const Bit8s ad_slot[0x20] = {
+ 0, 1, 2, 3, 4, 5, -1, -1, 6, 7, 8, 9, 10, 11, -1, -1,
+ 12, 13, 14, 15, 16, 17, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+};
+
+static const Bit8u ch_slot[18] = {
+ 0, 1, 2, 6, 7, 8, 12, 13, 14, 18, 19, 20, 24, 25, 26, 30, 31, 32
+};
+
+/*
+ * Envelope generator
+ */
+
+static void OPL3_EnvelopeGenOff(opl3_slot *slot);
+static void OPL3_EnvelopeGenAttack(opl3_slot *slot);
+static void OPL3_EnvelopeGenDecay(opl3_slot *slot);
+static void OPL3_EnvelopeGenSustain(opl3_slot *slot);
+static void OPL3_EnvelopeGenRelease(opl3_slot *slot);
+
+typedef void(*envelope_genfunc)(opl3_slot *slot);
+
+envelope_genfunc envelope_gen[5] = {
+ OPL3_EnvelopeGenOff,
+ OPL3_EnvelopeGenAttack,
+ OPL3_EnvelopeGenDecay,
+ OPL3_EnvelopeGenSustain,
+ OPL3_EnvelopeGenRelease
+};
+
+enum envelope_gen_num
+{
+ envelope_gen_num_off = 0,
+ envelope_gen_num_attack = 1,
+ envelope_gen_num_decay = 2,
+ envelope_gen_num_sustain = 3,
+ envelope_gen_num_release = 4
+};
+
+static Bit8u OPL3_EnvelopeCalcRate(opl3_slot *slot, Bit8u reg_rate)
+{
+ Bit8u rate;
+ if (reg_rate == 0x00)
+ {
+ return 0x00;
+ }
+ rate = (reg_rate << 2)
+ + (slot->reg_ksr ? slot->channel->ksv : (slot->channel->ksv >> 2));
+ if (rate > 0x3c)
+ {
+ rate = 0x3c;
+ }
+ return rate;
+}
+
+static void OPL3_EnvelopeUpdateKSL(opl3_slot *slot)
+{
+ Bit16s ksl = (kslrom[slot->channel->f_num >> 6] << 2)
+ - ((0x08 - slot->channel->block) << 5);
+ if (ksl < 0)
+ {
+ ksl = 0;
+ }
+ slot->eg_ksl = (Bit8u)ksl;
+}
+
+static void OPL3_EnvelopeUpdateRate(opl3_slot *slot)
+{
+ switch (slot->eg_gen)
+ {
+ case envelope_gen_num_off:
+ case envelope_gen_num_attack:
+ slot->eg_rate = OPL3_EnvelopeCalcRate(slot, slot->reg_ar);
+ break;
+ case envelope_gen_num_decay:
+ slot->eg_rate = OPL3_EnvelopeCalcRate(slot, slot->reg_dr);
+ break;
+ case envelope_gen_num_sustain:
+ case envelope_gen_num_release:
+ slot->eg_rate = OPL3_EnvelopeCalcRate(slot, slot->reg_rr);
+ break;
+ }
+}
+
+static void OPL3_EnvelopeGenOff(opl3_slot *slot)
+{
+ slot->eg_rout = 0x1ff;
+}
+
+static void OPL3_EnvelopeGenAttack(opl3_slot *slot)
+{
+ if (slot->eg_rout == 0x00)
+ {
+ slot->eg_gen = envelope_gen_num_decay;
+ OPL3_EnvelopeUpdateRate(slot);
+ return;
+ }
+ slot->eg_rout += ((~slot->eg_rout) * slot->eg_inc) >> 3;
+ if (slot->eg_rout < 0x00)
+ {
+ slot->eg_rout = 0x00;
+ }
+}
+
+static void OPL3_EnvelopeGenDecay(opl3_slot *slot)
+{
+ if (slot->eg_rout >= slot->reg_sl << 4)
+ {
+ slot->eg_gen = envelope_gen_num_sustain;
+ OPL3_EnvelopeUpdateRate(slot);
+ return;
+ }
+ slot->eg_rout += slot->eg_inc;
+}
+
+static void OPL3_EnvelopeGenSustain(opl3_slot *slot)
+{
+ if (!slot->reg_type)
+ {
+ OPL3_EnvelopeGenRelease(slot);
+ }
+}
+
+static void OPL3_EnvelopeGenRelease(opl3_slot *slot)
+{
+ if (slot->eg_rout >= 0x1ff)
+ {
+ slot->eg_gen = envelope_gen_num_off;
+ slot->eg_rout = 0x1ff;
+ OPL3_EnvelopeUpdateRate(slot);
+ return;
+ }
+ slot->eg_rout += slot->eg_inc;
+}
+
+static void OPL3_EnvelopeCalc(opl3_slot *slot)
+{
+ Bit8u rate_h, rate_l;
+ Bit8u inc = 0;
+ rate_h = slot->eg_rate >> 2;
+ rate_l = slot->eg_rate & 3;
+ if (eg_incsh[rate_h] > 0)
+ {
+ if ((slot->chip->timer & ((1 << eg_incsh[rate_h]) - 1)) == 0)
+ {
+ inc = eg_incstep[eg_incdesc[rate_h]][rate_l]
+ [((slot->chip->timer)>> eg_incsh[rate_h]) & 0x07];
+ }
+ }
+ else
+ {
+ inc = eg_incstep[eg_incdesc[rate_h]][rate_l]
+ [slot->chip->timer & 0x07] << (-eg_incsh[rate_h]);
+ }
+ slot->eg_inc = inc;
+ slot->eg_out = slot->eg_rout + (slot->reg_tl << 2)
+ + (slot->eg_ksl >> kslshift[slot->reg_ksl]) + *slot->trem;
+ if (slot->eg_out > 0x1ff) /* TODO: Remove this if possible */
+ {
+ slot->eg_out = 0x1ff;
+ }
+ slot->eg_out <<= 3;
+
+ envelope_gen[slot->eg_gen](slot);
+}
+
+static void OPL3_EnvelopeKeyOn(opl3_slot *slot, Bit8u type)
+{
+ if (!slot->key)
+ {
+ slot->eg_gen = envelope_gen_num_attack;
+ OPL3_EnvelopeUpdateRate(slot);
+ if ((slot->eg_rate >> 2) == 0x0f)
+ {
+ slot->eg_gen = envelope_gen_num_decay;
+ OPL3_EnvelopeUpdateRate(slot);
+ slot->eg_rout = 0x00;
+ }
+ slot->pg_phase = 0x00;
+ }
+ slot->key |= type;
+}
+
+static void OPL3_EnvelopeKeyOff(opl3_slot *slot, Bit8u type)
+{
+ if (slot->key)
+ {
+ slot->key &= (~type);
+ if (!slot->key)
+ {
+ slot->eg_gen = envelope_gen_num_release;
+ OPL3_EnvelopeUpdateRate(slot);
+ }
+ }
+}
+
+/*
+ * Phase Generator
+ */
+
+static void OPL3_PhaseGenerate(opl3_slot *slot)
+{
+ Bit16u f_num;
+ Bit32u basefreq;
+
+ f_num = slot->channel->f_num;
+ if (slot->reg_vib)
+ {
+ Bit8s range;
+ Bit8u vibpos;
+
+ range = (f_num >> 7) & 7;
+ vibpos = slot->chip->vibpos;
+
+ if (!(vibpos & 3))
+ {
+ range = 0;
+ }
+ else if (vibpos & 1)
+ {
+ range >>= 1;
+ }
+ range >>= slot->chip->vibshift;
+
+ if (vibpos & 4)
+ {
+ range = -range;
+ }
+ f_num += range;
+ }
+ basefreq = (f_num << slot->channel->block) >> 1;
+ slot->pg_phase += (basefreq * mt[slot->reg_mult]) >> 1;
+}
+
+/*
+ * Noise Generator
+ */
+
+static void OPL3_NoiseGenerate(opl3_chip *chip)
+{
+ if (chip->noise & 0x01)
+ {
+ chip->noise ^= 0x800302;
+ }
+ chip->noise >>= 1;
+}
+
+/*
+ * Slot
+ */
+
+static void OPL3_SlotWrite20(opl3_slot *slot, Bit8u data)
+{
+ if ((data >> 7) & 0x01)
+ {
+ slot->trem = &slot->chip->tremolo;
+ }
+ else
+ {
+ slot->trem = (Bit8u*)&slot->chip->zeromod;
+ }
+ slot->reg_vib = (data >> 6) & 0x01;
+ slot->reg_type = (data >> 5) & 0x01;
+ slot->reg_ksr = (data >> 4) & 0x01;
+ slot->reg_mult = data & 0x0f;
+ OPL3_EnvelopeUpdateRate(slot);
+}
+
+static void OPL3_SlotWrite40(opl3_slot *slot, Bit8u data)
+{
+ slot->reg_ksl = (data >> 6) & 0x03;
+ slot->reg_tl = data & 0x3f;
+ OPL3_EnvelopeUpdateKSL(slot);
+}
+
+static void OPL3_SlotWrite60(opl3_slot *slot, Bit8u data)
+{
+ slot->reg_ar = (data >> 4) & 0x0f;
+ slot->reg_dr = data & 0x0f;
+ OPL3_EnvelopeUpdateRate(slot);
+}
+
+static void OPL3_SlotWrite80(opl3_slot *slot, Bit8u data)
+{
+ slot->reg_sl = (data >> 4) & 0x0f;
+ if (slot->reg_sl == 0x0f)
+ {
+ slot->reg_sl = 0x1f;
+ }
+ slot->reg_rr = data & 0x0f;
+ OPL3_EnvelopeUpdateRate(slot);
+}
+
+static void OPL3_SlotWriteE0(opl3_slot *slot, Bit8u data)
+{
+ slot->reg_wf = data & 0x07;
+ if (slot->chip->newm == 0x00)
+ {
+ slot->reg_wf &= 0x03;
+ }
+
+ switch (slot->reg_wf)
+ {
+ case 1:
+ case 4:
+ case 5:
+ slot->maskzero = 0x200;
+ break;
+ case 3:
+ slot->maskzero = 0x100;
+ break;
+ default:
+ slot->maskzero = 0;
+ break;
+ }
+
+ switch (slot->reg_wf)
+ {
+ case 4:
+ slot->signpos = (31-8); /* sigext of (phase & 0x100) */
+ break;
+ case 0:
+ case 6:
+ case 7:
+ slot->signpos = (31-9); /* sigext of (phase & 0x200) */
+ break;
+ default:
+ slot->signpos = (31-16); /* set "neg" to zero */
+ break;
+ }
+
+ switch (slot->reg_wf)
+ {
+ case 4:
+ case 5:
+ slot->phaseshift = 1;
+ break;
+ case 6:
+ slot->phaseshift = 16; /* set phase to zero and flag for non-sin wave */
+ break;
+ case 7:
+ slot->phaseshift = 32; /* no shift (work by mod 32), but flag for non-sin wave */
+ break;
+ default:
+ slot->phaseshift = 0;
+ break;
+ }
+}
+
+static void OPL3_SlotGeneratePhase(opl3_slot *slot, Bit16u phase)
+{
+ Bit32u neg, level;
+ Bit8u phaseshift;
+
+ /* Fast paths for mute segments */
+ if (phase & slot->maskzero)
+ {
+ slot->out = 0;
+ return;
+ }
+
+ neg = (Bit32s)((Bit32u)phase << slot->signpos) >> 31;
+ phaseshift = slot->phaseshift;
+ level = slot->eg_out;
+
+ phase <<= phaseshift;
+ if (phaseshift <= 1)
+ {
+ level += logsinrom[phase & 0x1ff];
+ }
+ else
+ {
+ level += ((phase ^ neg) & 0x3ff) << 3;
+ }
+ slot->out = exprom[level & 0xff] >> (level >> 8) ^ neg;
+}
+
+static void OPL3_SlotGenerate(opl3_slot *slot)
+{
+ OPL3_SlotGeneratePhase(slot, (Bit16u)(slot->pg_phase >> 9) + *slot->mod);
+}
+
+static void OPL3_SlotGenerateZM(opl3_slot *slot)
+{
+ OPL3_SlotGeneratePhase(slot, (Bit16u)(slot->pg_phase >> 9));
+}
+
+static void OPL3_SlotCalcFB(opl3_slot *slot)
+{
+ if (slot->channel->fb != 0x00)
+ {
+ slot->fbmod = (slot->prout + slot->out) >> (0x09 - slot->channel->fb);
+ }
+ else
+ {
+ slot->fbmod = 0;
+ }
+ slot->prout = slot->out;
+}
+
+/*
+ * Channel
+ */
+
+static void OPL3_ChannelSetupAlg(opl3_channel *channel);
+
+static void OPL3_ChannelUpdateRhythm(opl3_chip *chip, Bit8u data)
+{
+ opl3_channel *channel6;
+ opl3_channel *channel7;
+ opl3_channel *channel8;
+ Bit8u chnum;
+
+ chip->rhy = data & 0x3f;
+ if (chip->rhy & 0x20)
+ {
+ channel6 = &chip->channel[6];
+ channel7 = &chip->channel[7];
+ channel8 = &chip->channel[8];
+ channel6->out[0] = &channel6->slots[1]->out;
+ channel6->out[1] = &channel6->slots[1]->out;
+ channel6->out[2] = &chip->zeromod;
+ channel6->out[3] = &chip->zeromod;
+ channel7->out[0] = &channel7->slots[0]->out;
+ channel7->out[1] = &channel7->slots[0]->out;
+ channel7->out[2] = &channel7->slots[1]->out;
+ channel7->out[3] = &channel7->slots[1]->out;
+ channel8->out[0] = &channel8->slots[0]->out;
+ channel8->out[1] = &channel8->slots[0]->out;
+ channel8->out[2] = &channel8->slots[1]->out;
+ channel8->out[3] = &channel8->slots[1]->out;
+ for (chnum = 6; chnum < 9; chnum++)
+ {
+ chip->channel[chnum].chtype = ch_drum;
+ }
+ OPL3_ChannelSetupAlg(channel6);
+ /*hh*/
+ if (chip->rhy & 0x01)
+ {
+ OPL3_EnvelopeKeyOn(channel7->slots[0], egk_drum);
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOff(channel7->slots[0], egk_drum);
+ }
+ /*tc*/
+ if (chip->rhy & 0x02)
+ {
+ OPL3_EnvelopeKeyOn(channel8->slots[1], egk_drum);
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOff(channel8->slots[1], egk_drum);
+ }
+ /*tom*/
+ if (chip->rhy & 0x04)
+ {
+ OPL3_EnvelopeKeyOn(channel8->slots[0], egk_drum);
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOff(channel8->slots[0], egk_drum);
+ }
+ /*sd*/
+ if (chip->rhy & 0x08)
+ {
+ OPL3_EnvelopeKeyOn(channel7->slots[1], egk_drum);
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOff(channel7->slots[1], egk_drum);
+ }
+ /*bd*/
+ if (chip->rhy & 0x10)
+ {
+ OPL3_EnvelopeKeyOn(channel6->slots[0], egk_drum);
+ OPL3_EnvelopeKeyOn(channel6->slots[1], egk_drum);
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOff(channel6->slots[0], egk_drum);
+ OPL3_EnvelopeKeyOff(channel6->slots[1], egk_drum);
+ }
+ }
+ else
+ {
+ for (chnum = 6; chnum < 9; chnum++)
+ {
+ chip->channel[chnum].chtype = ch_2op;
+ OPL3_ChannelSetupAlg(&chip->channel[chnum]);
+ OPL3_EnvelopeKeyOff(chip->channel[chnum].slots[0], egk_drum);
+ OPL3_EnvelopeKeyOff(chip->channel[chnum].slots[1], egk_drum);
+ }
+ }
+}
+
+static void OPL3_ChannelWriteA0(opl3_channel *channel, Bit8u data)
+{
+ if (channel->chip->newm && channel->chtype == ch_4op2)
+ {
+ return;
+ }
+ channel->f_num = (channel->f_num & 0x300) | data;
+ channel->ksv = (channel->block << 1)
+ | ((channel->f_num >> (0x09 - channel->chip->nts)) & 0x01);
+ OPL3_EnvelopeUpdateKSL(channel->slots[0]);
+ OPL3_EnvelopeUpdateKSL(channel->slots[1]);
+ OPL3_EnvelopeUpdateRate(channel->slots[0]);
+ OPL3_EnvelopeUpdateRate(channel->slots[1]);
+ if (channel->chip->newm && channel->chtype == ch_4op)
+ {
+ channel->pair->f_num = channel->f_num;
+ channel->pair->ksv = channel->ksv;
+ OPL3_EnvelopeUpdateKSL(channel->pair->slots[0]);
+ OPL3_EnvelopeUpdateKSL(channel->pair->slots[1]);
+ OPL3_EnvelopeUpdateRate(channel->pair->slots[0]);
+ OPL3_EnvelopeUpdateRate(channel->pair->slots[1]);
+ }
+}
+
+static void OPL3_ChannelWriteB0(opl3_channel *channel, Bit8u data)
+{
+ if (channel->chip->newm && channel->chtype == ch_4op2)
+ {
+ return;
+ }
+ channel->f_num = (channel->f_num & 0xff) | ((data & 0x03) << 8);
+ channel->block = (data >> 2) & 0x07;
+ channel->ksv = (channel->block << 1)
+ | ((channel->f_num >> (0x09 - channel->chip->nts)) & 0x01);
+ OPL3_EnvelopeUpdateKSL(channel->slots[0]);
+ OPL3_EnvelopeUpdateKSL(channel->slots[1]);
+ OPL3_EnvelopeUpdateRate(channel->slots[0]);
+ OPL3_EnvelopeUpdateRate(channel->slots[1]);
+ if (channel->chip->newm && channel->chtype == ch_4op)
+ {
+ channel->pair->f_num = channel->f_num;
+ channel->pair->block = channel->block;
+ channel->pair->ksv = channel->ksv;
+ OPL3_EnvelopeUpdateKSL(channel->pair->slots[0]);
+ OPL3_EnvelopeUpdateKSL(channel->pair->slots[1]);
+ OPL3_EnvelopeUpdateRate(channel->pair->slots[0]);
+ OPL3_EnvelopeUpdateRate(channel->pair->slots[1]);
+ }
+}
+
+static void OPL3_ChannelSetupAlg(opl3_channel *channel)
+{
+ if (channel->chtype == ch_drum)
+ {
+ switch (channel->alg & 0x01)
+ {
+ case 0x00:
+ channel->slots[0]->mod = &channel->slots[0]->fbmod;
+ channel->slots[1]->mod = &channel->slots[0]->out;
+ break;
+ case 0x01:
+ channel->slots[0]->mod = &channel->slots[0]->fbmod;
+ channel->slots[1]->mod = &channel->chip->zeromod;
+ break;
+ }
+ return;
+ }
+ if (channel->alg & 0x08)
+ {
+ return;
+ }
+ if (channel->alg & 0x04)
+ {
+ channel->pair->out[0] = &channel->chip->zeromod;
+ channel->pair->out[1] = &channel->chip->zeromod;
+ channel->pair->out[2] = &channel->chip->zeromod;
+ channel->pair->out[3] = &channel->chip->zeromod;
+ switch (channel->alg & 0x03)
+ {
+ case 0x00:
+ channel->pair->slots[0]->mod = &channel->pair->slots[0]->fbmod;
+ channel->pair->slots[1]->mod = &channel->pair->slots[0]->out;
+ channel->slots[0]->mod = &channel->pair->slots[1]->out;
+ channel->slots[1]->mod = &channel->slots[0]->out;
+ channel->out[0] = &channel->slots[1]->out;
+ channel->out[1] = &channel->chip->zeromod;
+ channel->out[2] = &channel->chip->zeromod;
+ channel->out[3] = &channel->chip->zeromod;
+ break;
+ case 0x01:
+ channel->pair->slots[0]->mod = &channel->pair->slots[0]->fbmod;
+ channel->pair->slots[1]->mod = &channel->pair->slots[0]->out;
+ channel->slots[0]->mod = &channel->chip->zeromod;
+ channel->slots[1]->mod = &channel->slots[0]->out;
+ channel->out[0] = &channel->pair->slots[1]->out;
+ channel->out[1] = &channel->slots[1]->out;
+ channel->out[2] = &channel->chip->zeromod;
+ channel->out[3] = &channel->chip->zeromod;
+ break;
+ case 0x02:
+ channel->pair->slots[0]->mod = &channel->pair->slots[0]->fbmod;
+ channel->pair->slots[1]->mod = &channel->chip->zeromod;
+ channel->slots[0]->mod = &channel->pair->slots[1]->out;
+ channel->slots[1]->mod = &channel->slots[0]->out;
+ channel->out[0] = &channel->pair->slots[0]->out;
+ channel->out[1] = &channel->slots[1]->out;
+ channel->out[2] = &channel->chip->zeromod;
+ channel->out[3] = &channel->chip->zeromod;
+ break;
+ case 0x03:
+ channel->pair->slots[0]->mod = &channel->pair->slots[0]->fbmod;
+ channel->pair->slots[1]->mod = &channel->chip->zeromod;
+ channel->slots[0]->mod = &channel->pair->slots[1]->out;
+ channel->slots[1]->mod = &channel->chip->zeromod;
+ channel->out[0] = &channel->pair->slots[0]->out;
+ channel->out[1] = &channel->slots[0]->out;
+ channel->out[2] = &channel->slots[1]->out;
+ channel->out[3] = &channel->chip->zeromod;
+ break;
+ }
+ }
+ else
+ {
+ switch (channel->alg & 0x01)
+ {
+ case 0x00:
+ channel->slots[0]->mod = &channel->slots[0]->fbmod;
+ channel->slots[1]->mod = &channel->slots[0]->out;
+ channel->out[0] = &channel->slots[1]->out;
+ channel->out[1] = &channel->chip->zeromod;
+ channel->out[2] = &channel->chip->zeromod;
+ channel->out[3] = &channel->chip->zeromod;
+ break;
+ case 0x01:
+ channel->slots[0]->mod = &channel->slots[0]->fbmod;
+ channel->slots[1]->mod = &channel->chip->zeromod;
+ channel->out[0] = &channel->slots[0]->out;
+ channel->out[1] = &channel->slots[1]->out;
+ channel->out[2] = &channel->chip->zeromod;
+ channel->out[3] = &channel->chip->zeromod;
+ break;
+ }
+ }
+}
+
+static void OPL3_ChannelWriteC0(opl3_channel *channel, Bit8u data)
+{
+ channel->fb = (data & 0x0e) >> 1;
+ channel->con = data & 0x01;
+ channel->alg = channel->con;
+ if (channel->chip->newm)
+ {
+ if (channel->chtype == ch_4op)
+ {
+ channel->pair->alg = 0x04 | (channel->con << 1) | (channel->pair->con);
+ channel->alg = 0x08;
+ OPL3_ChannelSetupAlg(channel->pair);
+ }
+ else if (channel->chtype == ch_4op2)
+ {
+ channel->alg = 0x04 | (channel->pair->con << 1) | (channel->con);
+ channel->pair->alg = 0x08;
+ OPL3_ChannelSetupAlg(channel);
+ }
+ else
+ {
+ OPL3_ChannelSetupAlg(channel);
+ }
+ }
+ else
+ {
+ OPL3_ChannelSetupAlg(channel);
+ }
+ if (channel->chip->newm)
+ {
+ channel->cha = ((data >> 4) & 0x01) ? ~0 : 0;
+ channel->chb = ((data >> 5) & 0x01) ? ~0 : 0;
+ }
+ else
+ {
+ channel->cha = channel->chb = ~0;
+ }
+}
+
+static void OPL3_ChannelKeyOn(opl3_channel *channel)
+{
+ if (channel->chip->newm)
+ {
+ if (channel->chtype == ch_4op)
+ {
+ OPL3_EnvelopeKeyOn(channel->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOn(channel->slots[1], egk_norm);
+ OPL3_EnvelopeKeyOn(channel->pair->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOn(channel->pair->slots[1], egk_norm);
+ }
+ else if (channel->chtype == ch_2op || channel->chtype == ch_drum)
+ {
+ OPL3_EnvelopeKeyOn(channel->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOn(channel->slots[1], egk_norm);
+ }
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOn(channel->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOn(channel->slots[1], egk_norm);
+ }
+}
+
+static void OPL3_ChannelKeyOff(opl3_channel *channel)
+{
+ if (channel->chip->newm)
+ {
+ if (channel->chtype == ch_4op)
+ {
+ OPL3_EnvelopeKeyOff(channel->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOff(channel->slots[1], egk_norm);
+ OPL3_EnvelopeKeyOff(channel->pair->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOff(channel->pair->slots[1], egk_norm);
+ }
+ else if (channel->chtype == ch_2op || channel->chtype == ch_drum)
+ {
+ OPL3_EnvelopeKeyOff(channel->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOff(channel->slots[1], egk_norm);
+ }
+ }
+ else
+ {
+ OPL3_EnvelopeKeyOff(channel->slots[0], egk_norm);
+ OPL3_EnvelopeKeyOff(channel->slots[1], egk_norm);
+ }
+}
+
+static void OPL3_ChannelSet4Op(opl3_chip *chip, Bit8u data)
+{
+ Bit8u bit;
+ Bit8u chnum;
+ for (bit = 0; bit < 6; bit++)
+ {
+ chnum = bit;
+ if (bit >= 3)
+ {
+ chnum += 9 - 3;
+ }
+ if ((data >> bit) & 0x01)
+ {
+ chip->channel[chnum].chtype = ch_4op;
+ chip->channel[chnum + 3].chtype = ch_4op2;
+ }
+ else
+ {
+ chip->channel[chnum].chtype = ch_2op;
+ chip->channel[chnum + 3].chtype = ch_2op;
+ }
+ }
+}
+
+static Bit16s OPL3_ClipSample(Bit32s sample)
+{
+ if (sample > 32767)
+ {
+ sample = 32767;
+ }
+ else if (sample < -32768)
+ {
+ sample = -32768;
+ }
+ return (Bit16s)sample;
+}
+
+static void OPL3_GenerateRhythm1(opl3_chip *chip)
+{
+ opl3_channel *channel6;
+ opl3_channel *channel7;
+ opl3_channel *channel8;
+ Bit16u phase14;
+ Bit16u phase17;
+ Bit16u phase;
+ Bit16u phasebit;
+
+ channel6 = &chip->channel[6];
+ channel7 = &chip->channel[7];
+ channel8 = &chip->channel[8];
+ OPL3_SlotGenerate(channel6->slots[0]);
+ phase14 = (channel7->slots[0]->pg_phase >> 9) & 0x3ff;
+ phase17 = (channel8->slots[1]->pg_phase >> 9) & 0x3ff;
+ phase = 0x00;
+ /*hh tc phase bit*/
+ phasebit = ((phase14 & 0x08) | (((phase14 >> 5) ^ phase14) & 0x04)
+ | (((phase17 >> 2) ^ phase17) & 0x08)) ? 0x01 : 0x00;
+ /*hh*/
+ phase = (phasebit << 9)
+ | (0x34 << ((phasebit ^ (chip->noise & 0x01)) << 1));
+ OPL3_SlotGeneratePhase(channel7->slots[0], phase);
+ /*tt*/
+ OPL3_SlotGenerateZM(channel8->slots[0]);
+}
+
+static void OPL3_GenerateRhythm2(opl3_chip *chip)
+{
+ opl3_channel *channel6;
+ opl3_channel *channel7;
+ opl3_channel *channel8;
+ Bit16u phase14;
+ Bit16u phase17;
+ Bit16u phase;
+ Bit16u phasebit;
+
+ channel6 = &chip->channel[6];
+ channel7 = &chip->channel[7];
+ channel8 = &chip->channel[8];
+ OPL3_SlotGenerate(channel6->slots[1]);
+ phase14 = (channel7->slots[0]->pg_phase >> 9) & 0x3ff;
+ phase17 = (channel8->slots[1]->pg_phase >> 9) & 0x3ff;
+ phase = 0x00;
+ /*hh tc phase bit*/
+ phasebit = ((phase14 & 0x08) | (((phase14 >> 5) ^ phase14) & 0x04)
+ | (((phase17 >> 2) ^ phase17) & 0x08)) ? 0x01 : 0x00;
+ /*sd*/
+ phase = (0x100 << ((phase14 >> 8) & 0x01)) ^ ((chip->noise & 0x01) << 8);
+ OPL3_SlotGeneratePhase(channel7->slots[1], phase);
+ /*tc*/
+ phase = 0x100 | (phasebit << 9);
+ OPL3_SlotGeneratePhase(channel8->slots[1], phase);
+}
+
+void OPL3_Generate(opl3_chip *chip, Bit16s *buf)
+{
+ Bit8u ii;
+ Bit8u jj;
+ Bit16s accm;
+
+ buf[1] = OPL3_ClipSample(chip->mixbuff[1]);
+
+ for (ii = 0; ii < 12; ii++)
+ {
+ OPL3_SlotCalcFB(&chip->chipslot[ii]);
+ OPL3_PhaseGenerate(&chip->chipslot[ii]);
+ OPL3_EnvelopeCalc(&chip->chipslot[ii]);
+ OPL3_SlotGenerate(&chip->chipslot[ii]);
+ }
+
+ for (ii = 12; ii < 15; ii++)
+ {
+ OPL3_SlotCalcFB(&chip->chipslot[ii]);
+ OPL3_PhaseGenerate(&chip->chipslot[ii]);
+ OPL3_EnvelopeCalc(&chip->chipslot[ii]);
+ }
+
+ if (chip->rhy & 0x20)
+ {
+ OPL3_GenerateRhythm1(chip);
+ }
+ else
+ {
+ OPL3_SlotGenerate(&chip->chipslot[12]);
+ OPL3_SlotGenerate(&chip->chipslot[13]);
+ OPL3_SlotGenerate(&chip->chipslot[14]);
+ }
+
+ chip->mixbuff[0] = 0;
+ for (ii = 0; ii < 18; ii++)
+ {
+ accm = 0;
+ for (jj = 0; jj < 4; jj++)
+ {
+ accm += *chip->channel[ii].out[jj];
+ }
+ chip->mixbuff[0] += (Bit16s)(accm & chip->channel[ii].cha);
+ }
+
+ for (ii = 15; ii < 18; ii++)
+ {
+ OPL3_SlotCalcFB(&chip->chipslot[ii]);
+ OPL3_PhaseGenerate(&chip->chipslot[ii]);
+ OPL3_EnvelopeCalc(&chip->chipslot[ii]);
+ }
+
+ if (chip->rhy & 0x20)
+ {
+ OPL3_GenerateRhythm2(chip);
+ }
+ else
+ {
+ OPL3_SlotGenerate(&chip->chipslot[15]);
+ OPL3_SlotGenerate(&chip->chipslot[16]);
+ OPL3_SlotGenerate(&chip->chipslot[17]);
+ }
+
+ buf[0] = OPL3_ClipSample(chip->mixbuff[0]);
+
+ for (ii = 18; ii < 33; ii++)
+ {
+ OPL3_SlotCalcFB(&chip->chipslot[ii]);
+ OPL3_PhaseGenerate(&chip->chipslot[ii]);
+ OPL3_EnvelopeCalc(&chip->chipslot[ii]);
+ OPL3_SlotGenerate(&chip->chipslot[ii]);
+ }
+
+ chip->mixbuff[1] = 0;
+ for (ii = 0; ii < 18; ii++)
+ {
+ accm = 0;
+ for (jj = 0; jj < 4; jj++)
+ {
+ accm += *chip->channel[ii].out[jj];
+ }
+ chip->mixbuff[1] += (Bit16s)(accm & chip->channel[ii].chb);
+ }
+
+ for (ii = 33; ii < 36; ii++)
+ {
+ OPL3_SlotCalcFB(&chip->chipslot[ii]);
+ OPL3_PhaseGenerate(&chip->chipslot[ii]);
+ OPL3_EnvelopeCalc(&chip->chipslot[ii]);
+ OPL3_SlotGenerate(&chip->chipslot[ii]);
+ }
+
+ OPL3_NoiseGenerate(chip);
+
+ if ((chip->timer & 0x3f) == 0x3f)
+ {
+ chip->tremolopos = (chip->tremolopos + 1) % 210;
+ }
+ if (chip->tremolopos < 105)
+ {
+ chip->tremolo = chip->tremolopos >> chip->tremoloshift;
+ }
+ else
+ {
+ chip->tremolo = (210 - chip->tremolopos) >> chip->tremoloshift;
+ }
+
+ if ((chip->timer & 0x3ff) == 0x3ff)
+ {
+ chip->vibpos = (chip->vibpos + 1) & 7;
+ }
+
+ chip->timer++;
+
+ while (chip->writebuf[chip->writebuf_cur].time <= chip->writebuf_samplecnt)
+ {
+ if (!(chip->writebuf[chip->writebuf_cur].reg & 0x200))
+ {
+ break;
+ }
+ chip->writebuf[chip->writebuf_cur].reg &= 0x1ff;
+ OPL3_WriteReg(chip, chip->writebuf[chip->writebuf_cur].reg,
+ chip->writebuf[chip->writebuf_cur].data);
+ chip->writebuf_cur = (chip->writebuf_cur + 1) % OPL_WRITEBUF_SIZE;
+ }
+ chip->writebuf_samplecnt++;
+}
+
+void OPL3_GenerateResampled(opl3_chip *chip, Bit16s *buf)
+{
+ while (chip->samplecnt >= chip->rateratio)
+ {
+ chip->oldsamples[0] = chip->samples[0];
+ chip->oldsamples[1] = chip->samples[1];
+ OPL3_Generate(chip, chip->samples);
+ chip->samplecnt -= chip->rateratio;
+ }
+ buf[0] = (Bit16s)((chip->oldsamples[0] * (chip->rateratio - chip->samplecnt)
+ + chip->samples[0] * chip->samplecnt) / chip->rateratio);
+ buf[1] = (Bit16s)((chip->oldsamples[1] * (chip->rateratio - chip->samplecnt)
+ + chip->samples[1] * chip->samplecnt) / chip->rateratio);
+ chip->samplecnt += 1 << RSM_FRAC;
+}
+
+void OPL3_Reset(opl3_chip *chip, Bit32u samplerate)
+{
+ Bit8u slotnum;
+ Bit8u channum;
+
+ memset(chip, 0, sizeof(opl3_chip));
+ for (slotnum = 0; slotnum < 36; slotnum++)
+ {
+ chip->chipslot[slotnum].chip = chip;
+ chip->chipslot[slotnum].mod = &chip->zeromod;
+ chip->chipslot[slotnum].eg_rout = 0x1ff;
+ chip->chipslot[slotnum].eg_out = 0x1ff << 3;
+ chip->chipslot[slotnum].eg_gen = envelope_gen_num_off;
+ chip->chipslot[slotnum].trem = (Bit8u*)&chip->zeromod;
+ chip->chipslot[slotnum].signpos = (31-9); /* for wf=0 need use sigext of (phase & 0x200) */
+ }
+ for (channum = 0; channum < 18; channum++)
+ {
+ chip->channel[channum].slots[0] = &chip->chipslot[ch_slot[channum]];
+ chip->channel[channum].slots[1] = &chip->chipslot[ch_slot[channum] + 3];
+ chip->chipslot[ch_slot[channum]].channel = &chip->channel[channum];
+ chip->chipslot[ch_slot[channum] + 3].channel = &chip->channel[channum];
+ if ((channum % 9) < 3)
+ {
+ chip->channel[channum].pair = &chip->channel[channum + 3];
+ }
+ else if ((channum % 9) < 6)
+ {
+ chip->channel[channum].pair = &chip->channel[channum - 3];
+ }
+ chip->channel[channum].chip = chip;
+ chip->channel[channum].out[0] = &chip->zeromod;
+ chip->channel[channum].out[1] = &chip->zeromod;
+ chip->channel[channum].out[2] = &chip->zeromod;
+ chip->channel[channum].out[3] = &chip->zeromod;
+ chip->channel[channum].chtype = ch_2op;
+ chip->channel[channum].cha = ~0;
+ chip->channel[channum].chb = ~0;
+ OPL3_ChannelSetupAlg(&chip->channel[channum]);
+ }
+ chip->noise = 0x306600;
+ chip->rateratio = (samplerate << RSM_FRAC) / 49716;
+ chip->tremoloshift = 4;
+ chip->vibshift = 1;
+}
+
+void OPL3_WriteReg(opl3_chip *chip, Bit16u reg, Bit8u v)
+{
+ Bit8u high = (reg >> 8) & 0x01;
+ Bit8u regm = reg & 0xff;
+ switch (regm & 0xf0)
+ {
+ case 0x00:
+ if (high)
+ {
+ switch (regm & 0x0f)
+ {
+ case 0x04:
+ OPL3_ChannelSet4Op(chip, v);
+ break;
+ case 0x05:
+ chip->newm = v & 0x01;
+ break;
+ }
+ }
+ else
+ {
+ switch (regm & 0x0f)
+ {
+ case 0x08:
+ chip->nts = (v >> 6) & 0x01;
+ break;
+ }
+ }
+ break;
+ case 0x20:
+ case 0x30:
+ if (ad_slot[regm & 0x1f] >= 0)
+ {
+ OPL3_SlotWrite20(&chip->chipslot[18 * high + ad_slot[regm & 0x1f]], v);
+ }
+ break;
+ case 0x40:
+ case 0x50:
+ if (ad_slot[regm & 0x1f] >= 0)
+ {
+ OPL3_SlotWrite40(&chip->chipslot[18 * high + ad_slot[regm & 0x1f]], v);
+ }
+ break;
+ case 0x60:
+ case 0x70:
+ if (ad_slot[regm & 0x1f] >= 0)
+ {
+ OPL3_SlotWrite60(&chip->chipslot[18 * high + ad_slot[regm & 0x1f]], v);
+ }
+ break;
+ case 0x80:
+ case 0x90:
+ if (ad_slot[regm & 0x1f] >= 0)
+ {
+ OPL3_SlotWrite80(&chip->chipslot[18 * high + ad_slot[regm & 0x1f]], v);
+ }
+ break;
+ case 0xe0:
+ case 0xf0:
+ if (ad_slot[regm & 0x1f] >= 0)
+ {
+ OPL3_SlotWriteE0(&chip->chipslot[18 * high + ad_slot[regm & 0x1f]], v);
+ }
+ break;
+ case 0xa0:
+ if ((regm & 0x0f) < 9)
+ {
+ OPL3_ChannelWriteA0(&chip->channel[9 * high + (regm & 0x0f)], v);
+ }
+ break;
+ case 0xb0:
+ if (regm == 0xbd && !high)
+ {
+ chip->tremoloshift = (((v >> 7) ^ 1) << 1) + 2;
+ chip->vibshift = ((v >> 6) & 0x01) ^ 1;
+ OPL3_ChannelUpdateRhythm(chip, v);
+ }
+ else if ((regm & 0x0f) < 9)
+ {
+ OPL3_ChannelWriteB0(&chip->channel[9 * high + (regm & 0x0f)], v);
+ if (v & 0x20)
+ {
+ OPL3_ChannelKeyOn(&chip->channel[9 * high + (regm & 0x0f)]);
+ }
+ else
+ {
+ OPL3_ChannelKeyOff(&chip->channel[9 * high + (regm & 0x0f)]);
+ }
+ }
+ break;
+ case 0xc0:
+ if ((regm & 0x0f) < 9)
+ {
+ OPL3_ChannelWriteC0(&chip->channel[9 * high + (regm & 0x0f)], v);
+ }
+ break;
+ }
+}
+
+void OPL3_WriteRegBuffered(opl3_chip *chip, Bit16u reg, Bit8u v)
+{
+ Bit64u time1, time2;
+
+ if (chip->writebuf[chip->writebuf_last].reg & 0x200)
+ {
+ OPL3_WriteReg(chip, chip->writebuf[chip->writebuf_last].reg & 0x1ff,
+ chip->writebuf[chip->writebuf_last].data);
+
+ chip->writebuf_cur = (chip->writebuf_last + 1) % OPL_WRITEBUF_SIZE;
+ chip->writebuf_samplecnt = chip->writebuf[chip->writebuf_last].time;
+ }
+
+ chip->writebuf[chip->writebuf_last].reg = reg | 0x200;
+ chip->writebuf[chip->writebuf_last].data = v;
+ time1 = chip->writebuf_lasttime + OPL_WRITEBUF_DELAY;
+ time2 = chip->writebuf_samplecnt;
+
+ if (time1 < time2)
+ {
+ time1 = time2;
+ }
+
+ chip->writebuf[chip->writebuf_last].time = time1;
+ chip->writebuf_lasttime = time1;
+ chip->writebuf_last = (chip->writebuf_last + 1) % OPL_WRITEBUF_SIZE;
+}
+
+void OPL3_GenerateStream(opl3_chip *chip, Bit16s *sndptr, Bit32u numsamples)
+{
+ Bit32u i;
+
+ for(i = 0; i < numsamples; i++)
+ {
+ OPL3_GenerateResampled(chip, sndptr);
+ sndptr += 2;
+ }
+}
+
+#define OPL3_MIN(A, B) (((A) > (B)) ? (B) : (A))
+#define OPL3_MAX(A, B) (((A) < (B)) ? (B) : (A))
+#define OPL3_CLAMP(V, MIN, MAX) OPL3_MAX(OPL3_MIN(V, MAX), MIN)
+
+void OPL3_GenerateStreamMix(opl3_chip *chip, Bit16s *sndptr, Bit32u numsamples)
+{
+ Bit32u i;
+ Bit16s sample[2];
+ Bit32s mix[2];
+
+ for(i = 0; i < numsamples; i++)
+ {
+ OPL3_GenerateResampled(chip, sample);
+ mix[0] = sndptr[0] + sample[0];
+ mix[1] = sndptr[1] + sample[1];
+ sndptr[0] = OPL3_CLAMP(mix[0], INT16_MIN, INT16_MAX);
+ sndptr[1] = OPL3_CLAMP(mix[1], INT16_MIN, INT16_MAX);
+ sndptr += 2;
+ }
+}
+
diff --git a/src/chips/nuked/old/nukedopl3.h b/src/chips/nuked/old/nukedopl3.h
new file mode 100644
index 0000000..254f275
--- /dev/null
+++ b/src/chips/nuked/old/nukedopl3.h
@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 2013-2016 Alexey Khokholov (Nuke.YKT)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Nuked OPL3 emulator.
+ * Thanks:
+ * MAME Development Team(Jarek Burczynski, Tatsuyuki Satoh):
+ * Feedback and Rhythm part calculation information.
+ * forums.submarine.org.uk(carbon14, opl3):
+ * Tremolo and phase generator calculation information.
+ * OPLx decapsulated(Matthew Gambrell, Olli Niemitalo):
+ * OPL2 ROMs.
+ *
+ * version: 1.7.4
+ */
+
+#ifndef OPL_OPL3_H
+#define OPL_OPL3_H
+
+#include <inttypes.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define OPL_WRITEBUF_SIZE 1024
+#define OPL_WRITEBUF_DELAY 2
+
+typedef uintptr_t Bitu;
+typedef intptr_t Bits;
+typedef uint64_t Bit64u;
+typedef int64_t Bit64s;
+typedef uint32_t Bit32u;
+typedef int32_t Bit32s;
+typedef uint16_t Bit16u;
+typedef int16_t Bit16s;
+typedef uint8_t Bit8u;
+typedef int8_t Bit8s;
+
+typedef struct _opl3_slot opl3_slot;
+typedef struct _opl3_channel opl3_channel;
+typedef struct _opl3_chip opl3_chip;
+
+struct _opl3_slot {
+ opl3_channel *channel;
+ opl3_chip *chip;
+ Bit16s out;
+ Bit16s fbmod;
+ Bit16s *mod;
+ Bit16s prout;
+ Bit16s eg_rout;
+ Bit16s eg_out;
+ Bit8u eg_inc;
+ Bit8u eg_gen;
+ Bit8u eg_rate;
+ Bit8u eg_ksl;
+ Bit8u *trem;
+ Bit8u reg_vib;
+ Bit8u reg_type;
+ Bit8u reg_ksr;
+ Bit8u reg_mult;
+ Bit8u reg_ksl;
+ Bit8u reg_tl;
+ Bit8u reg_ar;
+ Bit8u reg_dr;
+ Bit8u reg_sl;
+ Bit8u reg_rr;
+ Bit8u reg_wf;
+ Bit8u key;
+ Bit32u pg_phase;
+ Bit32u timer;
+
+ Bit16u maskzero;
+ Bit8u signpos;
+ Bit8u phaseshift;
+};
+
+struct _opl3_channel {
+ opl3_slot *slots[2];
+ opl3_channel *pair;
+ opl3_chip *chip;
+ Bit16s *out[4];
+ Bit8u chtype;
+ Bit16u f_num;
+ Bit8u block;
+ Bit8u fb;
+ Bit8u con;
+ Bit8u alg;
+ Bit8u ksv;
+ Bit16u cha, chb;
+};
+
+typedef struct _opl3_writebuf {
+ Bit64u time;
+ Bit16u reg;
+ Bit8u data;
+} opl3_writebuf;
+
+struct _opl3_chip {
+ opl3_channel channel[18];
+ opl3_slot chipslot[36];
+ Bit16u timer;
+ Bit8u newm;
+ Bit8u nts;
+ Bit8u rhy;
+ Bit8u vibpos;
+ Bit8u vibshift;
+ Bit8u tremolo;
+ Bit8u tremolopos;
+ Bit8u tremoloshift;
+ Bit32u noise;
+ Bit16s zeromod;
+ Bit32s mixbuff[2];
+ /* OPL3L */
+ Bit32s rateratio;
+ Bit32s samplecnt;
+ Bit16s oldsamples[2];
+ Bit16s samples[2];
+
+ Bit64u writebuf_samplecnt;
+ Bit32u writebuf_cur;
+ Bit32u writebuf_last;
+ Bit64u writebuf_lasttime;
+ opl3_writebuf writebuf[OPL_WRITEBUF_SIZE];
+};
+
+void OPL3_Generate(opl3_chip *chip, Bit16s *buf);
+void OPL3_GenerateResampled(opl3_chip *chip, Bit16s *buf);
+void OPL3_Reset(opl3_chip *chip, Bit32u samplerate);
+void OPL3_WriteReg(opl3_chip *chip, Bit16u reg, Bit8u v);
+void OPL3_WriteRegBuffered(opl3_chip *chip, Bit16u reg, Bit8u v);
+void OPL3_GenerateStream(opl3_chip *chip, Bit16s *sndptr, Bit32u numsamples);
+void OPL3_GenerateStreamMix(opl3_chip *chip, Bit16s *sndptr, Bit32u numsamples);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/chips/nuked_opl3.cpp b/src/chips/nuked_opl3.cpp
new file mode 100644
index 0000000..7833227
--- /dev/null
+++ b/src/chips/nuked_opl3.cpp
@@ -0,0 +1,67 @@
+#include "nuked_opl3.h"
+#include "nuked/nukedopl3.h"
+#include <cstring>
+
+NukedOPL3::NukedOPL3() :
+ OPLChipBase()
+{
+ m_chip = new opl3_chip;
+ reset(m_rate);
+}
+
+NukedOPL3::NukedOPL3(const NukedOPL3 &c):
+ OPLChipBase(c)
+{
+ m_chip = new opl3_chip;
+ std::memset(m_chip, 0, sizeof(opl3_chip));
+ reset(c.m_rate);
+}
+
+NukedOPL3::~NukedOPL3()
+{
+ opl3_chip *chip_r = reinterpret_cast<opl3_chip*>(m_chip);
+ delete chip_r;
+}
+
+void NukedOPL3::setRate(uint32_t rate)
+{
+ OPLChipBase::setRate(rate);
+ opl3_chip *chip_r = reinterpret_cast<opl3_chip*>(m_chip);
+ std::memset(chip_r, 0, sizeof(opl3_chip));
+ OPL3_Reset(chip_r, rate);
+}
+
+void NukedOPL3::reset()
+{
+ setRate(m_rate);
+}
+
+void NukedOPL3::reset(uint32_t rate)
+{
+ setRate(rate);
+}
+
+void NukedOPL3::writeReg(uint16_t addr, uint8_t data)
+{
+ opl3_chip *chip_r = reinterpret_cast<opl3_chip*>(m_chip);
+ OPL3_WriteReg(chip_r, addr, data);
+}
+
+int NukedOPL3::generate(int16_t *output, size_t frames)
+{
+ opl3_chip *chip_r = reinterpret_cast<opl3_chip*>(m_chip);
+ OPL3_GenerateStream(chip_r, output, (Bit32u)frames);
+ return (int)frames;
+}
+
+int NukedOPL3::generateAndMix(int16_t *output, size_t frames)
+{
+ opl3_chip *chip_r = reinterpret_cast<opl3_chip*>(m_chip);
+ OPL3_GenerateStreamMix(chip_r, output, (Bit32u)frames);
+ return (int)frames;
+}
+
+const char *NukedOPL3::emulatorName()
+{
+ return "Nuked OPL3 (v 1.8)";
+}
diff --git a/src/chips/nuked_opl3.h b/src/chips/nuked_opl3.h
new file mode 100644
index 0000000..db665fe
--- /dev/null
+++ b/src/chips/nuked_opl3.h
@@ -0,0 +1,23 @@
+#ifndef NUKED_OPL3_H
+#define NUKED_OPL3_H
+
+#include "opl_chip_base.h"
+
+class NukedOPL3 final : public OPLChipBase
+{
+ void *m_chip;
+public:
+ NukedOPL3();
+ NukedOPL3(const NukedOPL3 &c);
+ virtual ~NukedOPL3() override;
+
+ virtual void setRate(uint32_t rate) override;
+ virtual void reset() override;
+ virtual void reset(uint32_t rate) override;
+ virtual void writeReg(uint16_t addr, uint8_t data) override;
+ virtual int generate(int16_t *output, size_t frames) override;
+ virtual int generateAndMix(int16_t *output, size_t frames) override;
+ virtual const char *emulatorName() override;
+};
+
+#endif // NUKED_OPL3_H
diff --git a/src/chips/nuked_opl3_v174.cpp b/src/chips/nuked_opl3_v174.cpp
new file mode 100644
index 0000000..7188e83
--- /dev/null
+++ b/src/chips/nuked_opl3_v174.cpp
@@ -0,0 +1,67 @@
+#include "nuked_opl3_v174.h"
+#include "nuked/nukedopl3_174.h"
+#include <cstring>
+
+NukedOPL3v174::NukedOPL3v174() :
+ OPLChipBase()
+{
+ m_chip = new opl3_chip;
+ reset(m_rate);
+}
+
+NukedOPL3v174::NukedOPL3v174(const NukedOPL3v174 &c):
+ OPLChipBase(c)
+{
+ m_chip = new opl3_chip;
+ std::memset(m_chip, 0, sizeof(opl3_chip));
+ reset(c.m_rate);
+}
+
+NukedOPL3v174::~NukedOPL3v174()
+{
+ opl3_chip *chip_r = reinterpret_cast<opl3_chip*>(m_chip);
+ delete chip_r;
+}
+
+void NukedOPL3v174::setRate(uint32_t rate)
+{
+ OPLChipBase::setRate(rate);
+ opl3_chip *chip_r = reinterpret_cast<opl3_chip*>(m_chip);
+ std::memset(chip_r, 0, sizeof(opl3_chip));
+ OPL3v17_Reset(chip_r, rate);
+}
+
+void NukedOPL3v174::reset()
+{
+ setRate(m_rate);
+}
+
+void NukedOPL3v174::reset(uint32_t rate)
+{
+ setRate(rate);
+}
+
+void NukedOPL3v174::writeReg(uint16_t addr, uint8_t data)
+{
+ opl3_chip *chip_r = reinterpret_cast<opl3_chip*>(m_chip);
+ OPL3v17_WriteReg(chip_r, addr, data);
+}
+
+int NukedOPL3v174::generate(int16_t *output, size_t frames)
+{
+ opl3_chip *chip_r = reinterpret_cast<opl3_chip*>(m_chip);
+ OPL3v17_GenerateStream(chip_r, output, (Bit32u)frames);
+ return (int)frames;
+}
+
+int NukedOPL3v174::generateAndMix(int16_t *output, size_t frames)
+{
+ opl3_chip *chip_r = reinterpret_cast<opl3_chip*>(m_chip);
+ OPL3v17_GenerateStreamMix(chip_r, output, (Bit32u)frames);
+ return (int)frames;
+}
+
+const char *NukedOPL3v174::emulatorName()
+{
+ return "Nuked OPL3 (v 1.7.4)";
+}
diff --git a/src/chips/nuked_opl3_v174.h b/src/chips/nuked_opl3_v174.h
new file mode 100644
index 0000000..cf23187
--- /dev/null
+++ b/src/chips/nuked_opl3_v174.h
@@ -0,0 +1,23 @@
+#ifndef NUKED_OPL3174_H
+#define NUKED_OPL3174_H
+
+#include "opl_chip_base.h"
+
+class NukedOPL3v174 final : public OPLChipBase
+{
+ void *m_chip;
+public:
+ NukedOPL3v174();
+ NukedOPL3v174(const NukedOPL3v174 &c);
+ virtual ~NukedOPL3v174() override;
+
+ virtual void setRate(uint32_t rate) override;
+ virtual void reset() override;
+ virtual void reset(uint32_t rate) override;
+ virtual void writeReg(uint16_t addr, uint8_t data) override;
+ virtual int generate(int16_t *output, size_t frames) override;
+ virtual int generateAndMix(int16_t *output, size_t frames) override;
+ virtual const char *emulatorName() override;
+};
+
+#endif // NUKED_OPL3174_H
diff --git a/src/chips/opl_chip_base.cpp b/src/chips/opl_chip_base.cpp
new file mode 100644
index 0000000..65d4b73
--- /dev/null
+++ b/src/chips/opl_chip_base.cpp
@@ -0,0 +1,22 @@
+#include "opl_chip_base.h"
+
+OPLChipBase::OPLChipBase() :
+ m_rate(44100)
+{}
+
+OPLChipBase::OPLChipBase(const OPLChipBase &c):
+ m_rate(c.m_rate)
+{}
+
+OPLChipBase::~OPLChipBase()
+{}
+
+void OPLChipBase::setRate(uint32_t rate)
+{
+ m_rate = rate;
+}
+
+void OPLChipBase::reset(uint32_t rate)
+{
+ setRate(rate);
+}
diff --git a/src/chips/opl_chip_base.h b/src/chips/opl_chip_base.h
new file mode 100644
index 0000000..aa6934b
--- /dev/null
+++ b/src/chips/opl_chip_base.h
@@ -0,0 +1,25 @@
+#ifndef ONP_CHIP_BASE_H
+#define ONP_CHIP_BASE_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+class OPLChipBase
+{
+protected:
+ uint32_t m_rate;
+public:
+ OPLChipBase();
+ OPLChipBase(const OPLChipBase &c);
+ virtual ~OPLChipBase();
+
+ virtual void setRate(uint32_t rate);
+ virtual void reset() = 0;
+ virtual void reset(uint32_t rate);
+ virtual void writeReg(uint16_t addr, uint8_t data) = 0;
+ virtual int generate(int16_t *output, size_t frames) = 0;
+ virtual int generateAndMix(int16_t *output, size_t frames) = 0;
+ virtual const char* emulatorName() = 0;
+};
+
+#endif // ONP_CHIP_BASE_H
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-03 18:25:41 +0000