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(int* bufs[9 + 5], unsigned num) override;
        int 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