YM2413Burczynski.hh

Go to the documentation of this file.

#ifndef YM2413BURCZYNSKI_HH
#define YM2413BURCZYNSKI_HH
 
#include "YM2413Core.hh"
#include "FixedPoint.hh"
#include "serialize_meta.hh"
 
namespace openmsx {
namespace YM2413Burczynski {
 
class Channel;
 
using FreqIndex = FixedPoint<16>;
 
class Slot
{
public:
        Slot();
 
        void resetOperators();
 
        void updateGenerators(Channel& channel);
 
        inline int calcOutput(Channel& channel, unsigned eg_cnt, bool carrier,
                              unsigned lfo_am, int phase);
        inline int calc_slot_mod(Channel& channel, unsigned eg_cnt, bool carrier,
                                 unsigned lfo_pm, unsigned lfo_am);
        inline int calc_envelope(Channel& channel, unsigned eg_cnt, bool carrier);
        inline int calc_phase(Channel& channel, unsigned lfo_pm);
 
        enum KeyPart { KEY_MAIN = 1, KEY_RHYTHM = 2 };
        void setKeyOn(KeyPart part);
        void setKeyOff(KeyPart part);
        void setKeyOnOff(KeyPart part, bool enabled);
 
        bool isActive() const;
 
        void setFrequencyMultiplier(byte value);
 
        void setKeyScaleRate(bool value);
 
        void setEnvelopeSustained(bool value);
 
        void setVibrato(bool value);
 
        void setAmplitudeModulation(bool value);
 
        void setTotalLevel(Channel& channel, byte value);
 
        void setKeyScaleLevel(Channel& channel, byte value);
 
        void setWaveform(byte value);
 
        void setFeedbackShift(byte value);
 
        void setAttackRate(const Channel& channel, byte value);
 
        void setDecayRate(const Channel& channel, byte value);
 
        void setReleaseRate(const Channel& channel, byte value);
 
        void setSustainLevel(byte value);
 
        void updateFrequency(Channel& channel);
 
        template<typename Archive>
        void serialize(Archive& ar, unsigned version);
 
public: // public for serialization, otherwise could be private
        enum EnvelopeState {
                EG_DUMP, EG_ATTACK, EG_DECAY, EG_SUSTAIN, EG_RELEASE, EG_OFF
        };
 
private:
        void setEnvelopeState(EnvelopeState state);
 
        inline void updateTotalLevel(Channel& channel);
        inline void updateAttackRate(int kcodeScaled);
        inline void updateDecayRate(int kcodeScaled);
        inline void updateReleaseRate(int kcodeScaled);
 
        const unsigned* wavetable;      // waveform select
 
        // Phase Generator
        FreqIndex phase;        // frequency counter
        FreqIndex freq; // frequency counter step
 
        // Envelope Generator
        int TL;         // total level: TL << 2
        int TLL;        // adjusted now TL
        int egout;      // envelope counter
        int sl;         // sustain level: sl_tab[SL]
        EnvelopeState state;
 
        int op1_out[2]; // MOD output for feedback
        bool eg_sustain;// percussive/nonpercussive mode
        byte fb_shift;  // feedback shift value
 
        byte key;       // 0 = KEY OFF, >0 = KEY ON
 
        const byte* eg_sel_dp;
        const byte* eg_sel_ar;
        const byte* eg_sel_dr;
        const byte* eg_sel_rr;
        const byte* eg_sel_rs;
        unsigned eg_mask_dp; // == (1 << eg_sh_dp) - 1
        unsigned eg_mask_ar; // == (1 << eg_sh_ar) - 1
        unsigned eg_mask_dr; // == (1 << eg_sh_dr) - 1
        unsigned eg_mask_rr; // == (1 << eg_sh_rr) - 1
        unsigned eg_mask_rs; // == (1 << eg_sh_rs) - 1
        byte eg_sh_dp;  // (dump state)
        byte eg_sh_ar;  // (attack state)
        byte eg_sh_dr;  // (decay state)
        byte eg_sh_rr;  // (release state for non-perc.)
        byte eg_sh_rs;  // (release state for perc.mode)
 
        byte ar;        // attack rate: AR<<2
        byte dr;        // decay rate:  DR<<2
        byte rr;        // release rate:RR<<2
        byte KSR;       // key scale rate
        byte ksl;       // keyscale level
        byte mul;       // multiple: mul_tab[ML]
 
        // LFO
        byte AMmask;    // LFO Amplitude Modulation enable mask
        byte vib;       // LFO Phase Modulation enable flag (active high)
};
 
class Channel
{
public:
        Channel();
 
        inline int calcOutput(unsigned eg_cnt, unsigned lfo_pm, unsigned lfo_am, int fm);
 
        void setFrequency(int block_fnum);
 
        void setFrequencyLow(byte value);
 
        void setFrequencyHigh(byte value);
 
        void updateInstrumentPart(int part, byte value);
 
        void updateInstrument(const byte* inst);
 
        int getBlockFNum() const;
        FreqIndex getFrequencyIncrement() const;
        int getKeyScaleLevelBase() const;
        byte getKeyCode() const;
        bool isSustained() const;
        void setSustain(bool sustained);
 
        template<typename Archive>
        void serialize(Archive& ar, unsigned version);
 
        Slot mod;
        Slot car;
 
private:
        // phase generator state
        int block_fnum; // block+fnum
        FreqIndex fc;   // Freq. freqement base
        int ksl_base;   // KeyScaleLevel Base step
        bool sus;       // sus on/off (release speed in percussive mode)
};
 
class YM2413 final : public YM2413Core
{
public:
        YM2413();
 
        template<typename Archive>
        void serialize(Archive& ar, unsigned version);
 
private:
        // YM2413Core
        void reset() override;
        void writeReg(byte reg, byte value) override;
        byte peekReg(byte reg) const override;
        void generateChannels(float* bufs[9 + 5], unsigned num) override;
        float getAmplificationFactor() const override;
 
        void resetOperators();
 
        inline bool isRhythm() const;
 
        Channel& getChannelForReg(byte reg);
 
        void updateCustomInstrument(int part, byte value);
 
        void setRhythmFlags(byte old);
 
        Channel channels[9];
 
        unsigned eg_cnt;
 
        int noise_rng;
 
        unsigned idleSamples;
 
        using LFOAMIndex = FixedPoint< 6>;
        using LFOPMIndex = FixedPoint<10>;
        LFOAMIndex lfo_am_cnt;
        LFOPMIndex lfo_pm_cnt;
 
        byte inst_tab[19][8];
 
        byte reg[0x40];
};
 
} // namespace YM2413Burczynski
 
SERIALIZE_CLASS_VERSION(YM2413Burczynski::YM2413, 3);
SERIALIZE_CLASS_VERSION(YM2413Burczynski::Channel, 3);
SERIALIZE_CLASS_VERSION(YM2413Burczynski::Slot, 2);
 
} // namespace openmsx
 
#endif