aboutsummaryrefslogtreecommitdiff
path: root/src/dbopl.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/dbopl.cpp')
-rw-r--r--src/dbopl.cpp2045
1 files changed, 0 insertions, 2045 deletions
diff --git a/src/dbopl.cpp b/src/dbopl.cpp
deleted file mode 100644
index fb28e20..0000000
--- a/src/dbopl.cpp
+++ /dev/null
@@ -1,2045 +0,0 @@
-#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
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-04 23:17:32 +0000