dbopl.h

/*
 *  Copyright (C) 2002-2011  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.
 */

// Last synch with DOSBox SVN trunk r3752

#ifndef AUDIO_SOFTSYNTH_OPL_DBOPL_H
#define AUDIO_SOFTSYNTH_OPL_DBOPL_H

#include "common/scummsys.h"

#ifndef DISABLE_DOSBOX_OPL

namespace OPL {
namespace DOSBox {

//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

namespace DBOPL {

// Type aliases for the DBOPL code
typedef int Bits;
typedef uint Bitu;

typedef int8 Bit8s;
typedef uint8 Bit8u;

typedef int16 Bit16s;
typedef uint16 Bit16u;

typedef int32 Bit32s;
typedef uint32 Bit32u;

#define DB_FASTCALL
#define GCC_UNLIKELY(x) (x)
#define INLINE inline
// -------------------------------

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();
};

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();
};

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 Generate( Bit32u samples );
    void Setup( Bit32u r );

    Chip();
};

void InitTables();

}       //Namespace
} // End of namespace DOSBox
} // End of namespace OPL

#endif // !DISABLE_DOSBOX_OPL

#endif