V9990CmdEngine.hh

Go to the documentation of this file.

#ifndef V9990CMDENGINE_HH
#define V9990CMDENGINE_HH
 
#include "Observer.hh"
#include "EmuTime.hh"
#include "serialize_meta.hh"
#include "openmsx.hh"
 
namespace openmsx {
 
class V9990;
class V9990VRAM;
class Setting;
class RenderSettings;
class BooleanSetting;
 
class V9990CmdEngine final : private Observer<Setting>
{
public:
        // status bits
        static constexpr byte TR = 0x80;
        static constexpr byte BD = 0x10;
        static constexpr byte CE = 0x01;
 
        V9990CmdEngine(V9990& vdp, EmuTime::param time,
                       RenderSettings& settings);
        ~V9990CmdEngine();
 
        void reset(EmuTime::param time);
 
        inline void sync(EmuTime::param time) {
                if (CMD >> 4) sync2(time);
        }
        void sync2(EmuTime::param time);
 
        void setCmdReg(byte reg, byte val, EmuTime::param time);
 
        void setCmdData(byte value, EmuTime::param time);
 
        [[nodiscard]] byte getCmdData(EmuTime::param time);
 
        [[nodiscard]] byte peekCmdData(EmuTime::param time) const;
 
        [[nodiscard]] byte getStatus(EmuTime::param time) const {
                // note: used for both normal and debug read
                const_cast<V9990CmdEngine*>(this)->sync(time);
                return status;
        }
 
        [[nodiscard]] word getBorderX(EmuTime::param time) const {
                // note: used for both normal and debug read
                const_cast<V9990CmdEngine*>(this)->sync(time);
                return borderX;
        }
 
        [[nodiscard]] EmuTime estimateCmdEnd() const;
 
        [[nodiscard]] const V9990& getVDP() const { return vdp; }
        [[nodiscard]] bool getBrokenTiming() const { return brokenTiming; }
 
        template<typename Archive>
        void serialize(Archive& ar, unsigned version);
 
private:
        class V9990P1 {
        public:
                using Type = byte;
                static constexpr word BITS_PER_PIXEL  = 4;
                static constexpr word PIXELS_PER_BYTE = 2;
                static inline unsigned getPitch(unsigned width);
                static inline unsigned addressOf(unsigned x, unsigned y, unsigned pitch);
                static inline byte point(V9990VRAM& vram,
                                         unsigned x, unsigned y, unsigned pitch);
                static inline byte shift(byte value, unsigned fromX, unsigned toX);
                static inline byte shiftMask(unsigned x);
                static inline std::span<const byte, 256 * 256> getLogOpLUT(byte op);
                static inline byte logOp(std::span<const byte, 256 * 256> lut, byte src, byte dst);
                static inline void pset(
                        V9990VRAM& vram, unsigned x, unsigned y, unsigned pitch,
                        byte srcColor, word mask, std::span<const byte, 256 * 256> lut, byte op);
                static inline void psetColor(
                        V9990VRAM& vram, unsigned x, unsigned y, unsigned pitch,
                        word color, word mask, std::span<const byte, 256 * 256> lut, byte op);
        };
 
        class V9990P2 {
        public:
                using Type = byte;
                static constexpr word BITS_PER_PIXEL  = 4;
                static constexpr word PIXELS_PER_BYTE = 2;
                static inline unsigned getPitch(unsigned width);
                static inline unsigned addressOf(unsigned x, unsigned y, unsigned pitch);
                static inline byte point(V9990VRAM& vram,
                                         unsigned x, unsigned y, unsigned pitch);
                static inline byte shift(byte value, unsigned fromX, unsigned toX);
                static inline byte shiftMask(unsigned x);
                static inline std::span<const byte, 256 * 256> getLogOpLUT(byte op);
                static inline byte logOp(std::span<const byte, 256 * 256> lut, byte src, byte dst);
                static inline void pset(
                        V9990VRAM& vram, unsigned x, unsigned y, unsigned pitch,
                        byte srcColor, word mask, std::span<const byte, 256 * 256> lut, byte op);
                static inline void psetColor(
                        V9990VRAM& vram, unsigned x, unsigned y, unsigned pitch,
                        word color, word mask, std::span<const byte, 256 * 256> lut, byte op);
        };
 
        class V9990Bpp2 {
        public:
                using Type = byte;
                static constexpr word BITS_PER_PIXEL  = 2;
                static constexpr word PIXELS_PER_BYTE = 4;
                static inline unsigned getPitch(unsigned width);
                static inline unsigned addressOf(unsigned x, unsigned y, unsigned pitch);
                static inline byte point(V9990VRAM& vram,
                                         unsigned x, unsigned y, unsigned pitch);
                static inline byte shift(byte value, unsigned fromX, unsigned toX);
                static inline byte shiftMask(unsigned x);
                static inline std::span<const byte, 256 * 256> getLogOpLUT(byte op);
                static inline byte logOp(std::span<const byte, 256 * 256> lut, byte src, byte dst);
                static inline void pset(
                        V9990VRAM& vram, unsigned x, unsigned y, unsigned pitch,
                        byte srcColor, word mask, std::span<const byte, 256 * 256> lut, byte op);
                static inline void psetColor(
                        V9990VRAM& vram, unsigned x, unsigned y, unsigned pitch,
                        word color, word mask, std::span<const byte, 256 * 256> lut, byte op);
        };
 
        class V9990Bpp4 {
        public:
                using Type = byte;
                static constexpr word BITS_PER_PIXEL  = 4;
                static constexpr word PIXELS_PER_BYTE = 2;
                static inline unsigned getPitch(unsigned width);
                static inline unsigned addressOf(unsigned x, unsigned y, unsigned pitch);
                static inline byte point(V9990VRAM& vram,
                                         unsigned x, unsigned y, unsigned pitch);
                static inline byte shift(byte value, unsigned fromX, unsigned toX);
                static inline byte shiftMask(unsigned x);
                static inline std::span<const byte, 256 * 256> getLogOpLUT(byte op);
                static inline byte logOp(std::span<const byte, 256 * 256> lut, byte src, byte dst);
                static inline void pset(
                        V9990VRAM& vram, unsigned x, unsigned y, unsigned pitch,
                        byte srcColor, word mask, std::span<const byte, 256 * 256> lut, byte op);
                static inline void psetColor(
                        V9990VRAM& vram, unsigned x, unsigned y, unsigned pitch,
                        word color, word mask, std::span<const byte, 256 * 256> lut, byte op);
        };
 
        class V9990Bpp8 {
        public:
                using Type = byte;
                static constexpr word BITS_PER_PIXEL  = 8;
                static constexpr word PIXELS_PER_BYTE = 1;
                static inline unsigned getPitch(unsigned width);
                static inline unsigned addressOf(unsigned x, unsigned y, unsigned pitch);
                static inline byte point(V9990VRAM& vram,
                                         unsigned x, unsigned y, unsigned pitch);
                static inline byte shift(byte value, unsigned fromX, unsigned toX);
                static inline byte shiftMask(unsigned x);
                static inline std::span<const byte, 256 * 256> getLogOpLUT(byte op);
                static inline byte logOp(std::span<const byte, 256 * 256> lut, byte src, byte dst);
                static inline void pset(
                        V9990VRAM& vram, unsigned x, unsigned y, unsigned pitch,
                        byte srcColor, word mask, std::span<const byte, 256 * 256> lut, byte op);
                static inline void psetColor(
                        V9990VRAM& vram, unsigned x, unsigned y, unsigned pitch,
                        word color, word mask, std::span<const byte, 256 * 256> lut, byte op);
        };
 
        class V9990Bpp16 {
        public:
                using Type = word;
                static constexpr word BITS_PER_PIXEL  = 16;
                static constexpr word PIXELS_PER_BYTE = 0;
                static inline unsigned getPitch(unsigned width);
                static inline unsigned addressOf(unsigned x, unsigned y, unsigned pitch);
                static inline word point(V9990VRAM& vram,
                                         unsigned x, unsigned y, unsigned pitch);
                static inline word shift(word value, unsigned fromX, unsigned toX);
                static inline word shiftMask(unsigned x);
                static inline std::span<const byte, 256 * 256> getLogOpLUT(byte op);
                static inline word logOp(std::span<const byte, 256 * 256> lut, word src, word dst, bool transp);
                static inline void pset(
                        V9990VRAM& vram, unsigned x, unsigned y, unsigned pitch,
                        word srcColor, word mask, std::span<const byte, 256 * 256> lut, byte op);
                static inline void psetColor(
                        V9990VRAM& vram, unsigned x, unsigned y, unsigned pitch,
                        word color, word mask, std::span<const byte, 256 * 256> lut, byte op);
        };
 
        void startSTOP  (EmuTime::param time);
        void startLMMC  (EmuTime::param time);
        void startLMMC16(EmuTime::param time);
        void startLMMV  (EmuTime::param time);
        void startLMCM  (EmuTime::param time);
        void startLMCM16(EmuTime::param time);
        void startLMMM  (EmuTime::param time);
        void startCMMC  (EmuTime::param time);
        void startCMMK  (EmuTime::param time);
        void startCMMM  (EmuTime::param time);
        void startBMXL  (EmuTime::param time);
        void startBMLX  (EmuTime::param time);
        void startBMLL  (EmuTime::param time);
        void startBMLL16(EmuTime::param time);
        void startLINE  (EmuTime::param time);
        void startSRCH  (EmuTime::param time);
        template<typename Mode> void startPOINT(EmuTime::param time);
        template<typename Mode> void startPSET (EmuTime::param time);
        void startADVN  (EmuTime::param time);
 
                                void executeSTOP (EmuTime::param limit);
        template<typename Mode> void executeLMMC (EmuTime::param limit);
        template<typename Mode> void executeLMMV (EmuTime::param limit);
        template<typename Mode> void executeLMCM (EmuTime::param limit);
        template<typename Mode> void executeLMMM (EmuTime::param limit);
        template<typename Mode> void executeCMMC (EmuTime::param limit);
                                void executeCMMK (EmuTime::param limit);
        template<typename Mode> void executeCMMM (EmuTime::param limit);
        template<typename Mode> void executeBMXL (EmuTime::param limit);
        template<typename Mode> void executeBMLX (EmuTime::param limit);
        template<typename Mode> void executeBMLL (EmuTime::param limit);
        template<typename Mode> void executeLINE (EmuTime::param limit);
        template<typename Mode> void executeSRCH (EmuTime::param limit);
        template<typename Mode> void executePOINT(EmuTime::param limit);
                                void executePSET (EmuTime::param limit);
                                void executeADVN (EmuTime::param limit);
 
        RenderSettings& settings;
 
        std::shared_ptr<BooleanSetting> cmdTraceSetting;
 
        V9990& vdp;
        V9990VRAM& vram;
 
        EmuTime engineTime;
 
        unsigned srcAddress;
        unsigned dstAddress;
        unsigned nbBytes;
 
        word borderX;
 
        word ASX, ADX, ANX, ANY;
 
        word SX, SY, DX, DY, NX, NY;
        word WM, fgCol, bgCol;
        byte ARG, LOG, CMD;
 
        unsigned cmdMode; // TODO keep this up-to-date (now it's calculated at the start of a command)
 
        byte status;
 
        byte data;
 
        byte bitsLeft;
 
        byte partial;
 
        bool endAfterRead;
 
        bool brokenTiming;
 
        void cmdReady(EmuTime::param time);
 
        void reportV9990Command() const;
 
        // Observer<Setting>
        void update(const Setting& setting) noexcept override;
 
        void setCommandMode();
 
        [[nodiscard]] inline word getWrappedNX() const {
                return NX ? NX : 2048;
        }
        [[nodiscard]] inline word getWrappedNY() const {
                return NY ? NY : 4096;
        }
};
SERIALIZE_CLASS_VERSION(V9990CmdEngine, 2);
 
} // namespace openmsx
 
#endif