VDP.hh

Go to the documentation of this file.

#ifndef VDP_HH
#define VDP_HH
 
#include "MSXDevice.hh"
#include "Schedulable.hh"
#include "VideoSystemChangeListener.hh"
#include "SimpleDebuggable.hh"
#include "TclCallback.hh"
#include "InfoTopic.hh"
#include "IRQHelper.hh"
#include "Clock.hh"
#include "DisplayMode.hh"
#include "EnumSetting.hh"
#include "openmsx.hh"
 
#include "Observer.hh"
#include "gl_vec.hh"
#include "narrow.hh"
#include "outer.hh"
 
#include <memory>
#include <array>
 
namespace openmsx {
 
class PostProcessor;
class Renderer;
class VDPCmdEngine;
class VDPVRAM;
class MSXCPU;
class SpriteChecker;
class Display;
class RawFrame;
class Setting;
namespace VDPAccessSlots {
        enum class Delta : int;
        class Calculator;
}
 
class VDP final : public MSXDevice, private VideoSystemChangeListener
                , private Observer<Setting>
{
public:
        static constexpr int TICKS_PER_SECOND = 3579545 * 6; // 21.5MHz;
        using VDPClock = Clock<TICKS_PER_SECOND>;
 
        static constexpr int TICKS_PER_LINE = 1368;
 
        explicit VDP(const DeviceConfig& config);
        ~VDP() override;
 
        void powerUp(EmuTime::param time) override;
        void reset(EmuTime::param time) override;
        [[nodiscard]] byte readIO(word port, EmuTime::param time) override;
        [[nodiscard]] byte peekIO(word port, EmuTime::param time) const override;
        void writeIO(word port, byte value, EmuTime::param time) override;
 
        void getExtraDeviceInfo(TclObject& result) const override;
        [[nodiscard]] std::string_view getVersionString() const;
 
        [[nodiscard]] byte peekRegister(unsigned address) const;
        [[nodiscard]] byte peekStatusReg(byte reg, EmuTime::param time) const;
 
        void changeRegister(byte reg, byte val, EmuTime::param time);
 
 
        [[nodiscard]] PostProcessor* getPostProcessor() const;
 
        [[nodiscard]] inline bool isMSX1VDP() const {
                return (version & VM_MSX1) != 0;
        }
 
        [[nodiscard]] inline bool isVDPwithPALonly() const {
                return (version & VM_PAL) != 0;
        }
 
        [[nodiscard]] inline bool vdpLacksMirroring() const {
                return (version & VM_NO_MIRRORING) != 0;
        }
 
        [[nodiscard]] inline bool vdpHasPatColMirroring() const {
                return (version & VM_PALCOL_MIRRORING) != 0;
        }
 
        [[nodiscard]] inline bool isVDPwithVRAMremapping() const {
                return (version & VM_VRAM_REMAPPING) != 0;
        }
 
        [[nodiscard]] inline bool hasYJK() const {
                return (version & VM_YJK) != 0;
        }
 
        [[nodiscard]] std::array<std::array<uint8_t, 3>, 16> getMSX1Palette() const;
 
        [[nodiscard]] inline DisplayMode getDisplayMode() const {
                return displayMode;
        }
 
        [[nodiscard]] inline VDPVRAM& getVRAM() {
                return *vram;
        }
 
        [[nodiscard]] inline const RawFrame* isSuperimposing() const {
                // Note that bit 0 of r#0 has no effect on an V9938 or higher,
                // but this bit is masked out. Also note that on an MSX1, if
                // bit 0 of r#0 is enabled and there is no external video
                // source, then we lose sync.
                // Also note that because this property is fixed per frame we
                // cannot (re)calculate it from register values.
                return superimposing;
        }
 
        [[nodiscard]] inline SpriteChecker& getSpriteChecker() {
                return *spriteChecker;
        }
 
        [[nodiscard]] inline bool getTransparency() const {
                return (controlRegs[8] & 0x20) == 0;
        }
 
        [[nodiscard]] bool canSpriteColor0Collide() const {
                // On MSX1 (so far only tested a TMS9129(?)) sprites with
                // color=0 can always collide with other sprites. Though on
                // V99x8 (only tested V9958) collisions only occur when color 0
                // is not transparent. For more details see:
                //   https://github.com/openMSX/openMSX/issues/1198
                return isMSX1VDP() || !getTransparency();
        }
 
        [[nodiscard]] inline int getForegroundColor() const {
                return controlRegs[7] >> 4;
        }
 
        [[nodiscard]] inline byte getBackgroundColor() const {
                byte reg7 = controlRegs[7];
                if (displayMode.getByte() == DisplayMode::GRAPHIC7) {
                        return reg7;
                } else {
                        return reg7 & 0x0F;
                }
        }
 
        [[nodiscard]] inline int getBlinkForegroundColor() const {
                return controlRegs[12] >> 4;
        }
 
        [[nodiscard]] inline int getBlinkBackgroundColor() const {
                return controlRegs[12] & 0x0F;
        }
 
        [[nodiscard]] inline bool getBlinkState() const {
                return blinkState;
        }
 
        [[nodiscard]] int getPatternTableBase() const {
                return controlRegs[4] << 11;
        }
        [[nodiscard]] int getColorTableBase() const {
                return (controlRegs[10] << 14) | (controlRegs[3] << 6);
        }
        [[nodiscard]] int getNameTableBase() const {
                return controlRegs[2] << 10;
        }
        [[nodiscard]] int getSpritePatternTableBase() const {
                return controlRegs[6] << 11;
        }
        [[nodiscard]] int getSpriteAttributeTableBase() const {
                return (controlRegs[11] << 15) | (controlRegs[5] << 7);
        }
        [[nodiscard]] int getVramPointer() const {
                return vramPointer;
        }
 
        [[nodiscard]] inline uint16_t getPalette(unsigned index) const {
                return palette[index];
        }
        [[nodiscard]] inline std::span<const uint16_t, 16> getPalette() const {
                return palette;
        }
 
        void setPalette(unsigned index, word grb, EmuTime::param time);
 
        [[nodiscard]] inline bool isDisplayEnabled() const {
                return isDisplayArea && displayEnabled;
        }
 
        [[nodiscard]] inline bool spritesEnabled() const {
                return displayEnabled &&
                       (displayMode.getSpriteMode(isMSX1VDP()) != 0) &&
                       spriteEnabled;
        }
 
        [[nodiscard]] inline bool spritesEnabledFast() const {
                assert(displayMode.getSpriteMode(isMSX1VDP()) != 0);
                return displayEnabled && spriteEnabled;
        }
 
        [[nodiscard]] inline bool spritesEnabledRegister() const {
                return spriteEnabled;
        }
 
        [[nodiscard]] inline byte getVerticalScroll() const {
                return controlRegs[23];
        }
 
        [[nodiscard]] inline byte getHorizontalScrollLow() const {
                return controlRegs[27];
        }
 
        [[nodiscard]] inline byte getHorizontalScrollHigh() const {
                return controlRegs[26];
        }
 
        [[nodiscard]] inline bool isBorderMasked() const {
                return (controlRegs[25] & 0x02) != 0;
        }
 
        [[nodiscard]] inline bool isMultiPageScrolling() const {
                return (controlRegs[25] & 0x01) && (controlRegs[2] & 0x20);
        }
 
        [[nodiscard]] int getDisplayPage() const {
                return (controlRegs[2] >> 5) & 3;
        }
 
        [[nodiscard]] inline int getLineZero() const {
                return displayStart / TICKS_PER_LINE;
        }
 
        [[nodiscard]] inline bool isPalTiming() const {
                return palTiming;
        }
 
        [[nodiscard]] inline bool isInterlaced() const {
                return interlaced;
        }
 
        [[nodiscard]] inline bool isFastBlinkEnabled() const {
                return (controlRegs[1] & 4) != 0;
        }
 
        [[nodiscard]] inline bool isEvenOddEnabled() const {
                if (isFastBlinkEnabled()) return false;
                return (controlRegs[9] & 4) != 0;
        }
 
        [[nodiscard]] inline bool getEvenOdd() const {
                return (statusReg2 & 2) != 0;
        }
 
        [[nodiscard]] inline unsigned getEvenOddMask() const {
                // TODO: Verify which page is displayed on even fields.
                assert(!isFastBlinkEnabled());
                return (((~controlRegs[9] & 4) << 6) | ((statusReg2 & 2) << 7)) &
                       (!blinkState << 8);
        }
 
        [[nodiscard]] inline unsigned getEvenOddMask(int line) const {
                if (isFastBlinkEnabled()) {
                        // EO and IL not considered in this mode
                        auto p = calculateLineBlinkState(line);
                        return (!p.state) << 8;
                } else {
                        return getEvenOddMask();
                }
        }
 
        struct BlinkStateCount {
                bool state;
                int count;
        };
        [[nodiscard]] BlinkStateCount calculateLineBlinkState(unsigned line) const {
                assert(isFastBlinkEnabled());
 
                if (blinkCount == 0) { // not changing
                        return {blinkState, blinkCount};
                }
 
                unsigned evenLen = ((controlRegs[13] >> 4) & 0x0F) * 10;
                unsigned oddLen  = ((controlRegs[13] >> 0) & 0x0F) * 10;
                unsigned totalLen = evenLen + oddLen;
                assert(totalLen != 0); // because this implies 'blinkCount == 0'
                line %= totalLen; // reduce double flips
 
                bool resultState = blinkState; // initial guess, adjusted later
                if (blinkState) {
                        // We start in the 'even' period -> check first for
                        // even/odd transition, next for odd/even
                } else {
                        // We start in the 'odd' period -> do the opposite
                        std::swap(evenLen, oddLen);
                }
                int newCount = blinkCount - narrow<int>(line);
                if (newCount <= 0) {
                        // switch even->odd    (or odd->even)
                        resultState = !resultState;
                        newCount += narrow<int>(oddLen);
                        if (newCount <= 0) {
                                // switch odd->even   (or even->odd)
                                resultState = !resultState;
                                newCount += narrow<int>(evenLen);
                                assert(newCount > 0);
                        }
                }
                return {resultState, newCount};
        }
 
        [[nodiscard]] inline int getTicksThisFrame(EmuTime::param time) const {
                return narrow<int>(frameStartTime.getTicksTill_fast(time));
        }
 
        [[nodiscard]] inline EmuTime::param getFrameStartTime() const {
                return frameStartTime.getTime();
        }
 
        [[nodiscard]] inline int getSpriteSize() const {
                return ((controlRegs[1] & 2) << 2) + 8;
        }
 
        [[nodiscard]] inline bool isSpriteMag() const {
                return controlRegs[1] & 1;
        }
 
        [[nodiscard]] inline bool getCmdBit() const {
                return (controlRegs[25] & 0x40) != 0;
        }
 
        [[nodiscard]] inline int getLinesPerFrame() const {
                return palTiming ? 313 : 262;
        }
 
        [[nodiscard]] inline int getNumberOfLines() const {
                return controlRegs[9] & 0x80 ? 212 : 192;
        }
 
        [[nodiscard]] inline int getTicksPerFrame() const {
                return getLinesPerFrame() * TICKS_PER_LINE;
        }
 
        [[nodiscard]] inline bool isInsideFrame(EmuTime::param time) const {
                return time >= frameStartTime.getTime() &&
                        getTicksThisFrame(time) <= getTicksPerFrame();
        }
 
        [[nodiscard]] inline int getHorizontalAdjust() const {
                return horizontalAdjust;
        }
 
        [[nodiscard]] inline int getLeftSprites() const {
                return 100 + 102 + 56
                        + (horizontalAdjust - 7) * 4
                        + (displayMode.isTextMode() ? 36 : 0);
        }
 
        [[nodiscard]] inline int getLeftBorder() const {
                return getLeftSprites() + (isBorderMasked() ? 8 * 4 : 0);
        }
 
        [[nodiscard]] inline int getRightBorder() const {
                return getLeftSprites()
                        + (displayMode.isTextMode() ? 960 : 1024);
        }
 
        [[nodiscard]] inline int getLeftBackground() const {
                return getLeftSprites() + getHorizontalScrollLow() * 4;
        }
 
        [[nodiscard]] byte getStatusReg0() const { return statusReg0; }
 
        void setSpriteStatus(byte value)
        {
                statusReg0 = (statusReg0 & 0x80) | (value & 0x7F);
        }
 
        [[nodiscard]] bool getVRMode() const {
                return (controlRegs[8] & 8) != 0;
        }
 
        void setExternalVideoSource(const RawFrame* externalSource) {
                externalVideo = externalSource;
        }
 
        [[nodiscard]] bool getBrokenCmdTiming() const {
                return brokenCmdTiming;
        }
 
        [[nodiscard]] EmuTime getAccessSlot(EmuTime::param time, VDPAccessSlots::Delta delta) const;
 
        [[nodiscard]] VDPAccessSlots::Calculator getAccessSlotCalculator(
                EmuTime::param time, EmuTime::param limit) const;
 
        void scheduleCmdSync(EmuTime t) {
                if (auto now = getCurrentTime(); t <= now) {
                        // The largest amount of VDP cycles between 'progress'
                        // in command emulation:
                        // - worst case the LMMM takes 120+64 cycles to fully process one pixel
                        // - the largest gap between access slots is 70 cycles
                        // - but if we're unlucky the CPU steals that slot
                        int LARGEST_STALL = 184 + 2 * 70;
 
                        t = now + VDPClock::duration(LARGEST_STALL);
                }
                syncCmdDone.setSyncPoint(t);
        }
 
        [[nodiscard]] gl::ivec2 getMSXPos(EmuTime::param time) const {
                auto ticks = getTicksThisFrame(time);
                return {((ticks % VDP::TICKS_PER_LINE) - getLeftSprites()) / 2,
                         (ticks / VDP::TICKS_PER_LINE) - getLineZero()};
        }
 
        template<typename Archive>
        void serialize(Archive& ar, unsigned version);
 
private:
        void initTables();
 
        // VdpVersion bitmasks
        static constexpr unsigned VM_MSX1             =   1; // set-> MSX1,       unset-> MSX2 or MSX2+
        static constexpr unsigned VM_PAL              =   2; // set-> fixed PAL,  unset-> fixed NTSC or switchable
        static constexpr unsigned VM_NO_MIRRORING     =   4; // set-> no (screen2) mirroring
        static constexpr unsigned VM_PALCOL_MIRRORING =   8; // set-> pattern/color-table mirroring
        static constexpr unsigned VM_VRAM_REMAPPING   =  16; // set-> 4k,8/16k VRAM remapping
        static constexpr unsigned VM_TOSHIBA_PALETTE  =  32; // set-> has Toshiba palette
        static constexpr unsigned VM_YJK              =  64; // set-> has YJK (MSX2+)
        static constexpr unsigned VM_YM2220_PALETTE   = 128; // set-> has YM2220 palette
 
        enum VdpVersion {
                TMS99X8A   = VM_MSX1 | VM_PALCOL_MIRRORING | VM_VRAM_REMAPPING,
 
                TMS9929A   = VM_MSX1 | VM_PALCOL_MIRRORING | VM_VRAM_REMAPPING | VM_PAL,
 
                TMS9129    = VM_MSX1 | VM_PAL,
 
                TMS91X8    = VM_MSX1,
 
                T6950PAL   = VM_MSX1 | VM_TOSHIBA_PALETTE | VM_NO_MIRRORING | VM_PAL,
 
                T6950NTSC  = VM_MSX1 | VM_TOSHIBA_PALETTE | VM_NO_MIRRORING,
 
                T7937APAL  = VM_MSX1 | VM_TOSHIBA_PALETTE | VM_PAL,
 
                T7937ANTSC = VM_MSX1 | VM_TOSHIBA_PALETTE,
 
                YM2220PAL  = VM_MSX1 | VM_YM2220_PALETTE | VM_PALCOL_MIRRORING | VM_PAL,
 
                YM2220NTSC = VM_MSX1 | VM_YM2220_PALETTE | VM_PALCOL_MIRRORING,
 
                V9938      = 0,
 
                V9958      = VM_YJK,
        };
 
        struct SyncBase : public Schedulable {
                explicit SyncBase(const VDP& vdp_) : Schedulable(vdp_.getScheduler()) {}
                using Schedulable::removeSyncPoint;
                using Schedulable::setSyncPoint;
                using Schedulable::pendingSyncPoint;
        protected:
                ~SyncBase() = default;
        };
 
        struct SyncVSync final : public SyncBase {
                using SyncBase::SyncBase;
                void executeUntil(EmuTime::param time) override {
                        auto& vdp = OUTER(VDP, syncVSync);
                        vdp.execVSync(time);
                }
        } syncVSync;
 
        struct SyncDisplayStart final : public SyncBase {
                using SyncBase::SyncBase;
                void executeUntil(EmuTime::param time) override {
                        auto& vdp = OUTER(VDP, syncDisplayStart);
                        vdp.execDisplayStart(time);
                }
        } syncDisplayStart;
 
        struct SyncVScan final : public SyncBase {
                using SyncBase::SyncBase;
                void executeUntil(EmuTime::param time) override {
                        auto& vdp = OUTER(VDP, syncVScan);
                        vdp.execVScan(time);
                }
        } syncVScan;
 
        struct SyncHScan final : public SyncBase {
                using SyncBase::SyncBase;
                void executeUntil(EmuTime::param /*time*/) override {
                        auto& vdp = OUTER(VDP, syncHScan);
                        vdp.execHScan();
                }
        } syncHScan;
 
        struct SyncHorAdjust final : public SyncBase {
                using SyncBase::SyncBase;
                void executeUntil(EmuTime::param time) override {
                        auto& vdp = OUTER(VDP, syncHorAdjust);
                        vdp.execHorAdjust(time);
                }
        } syncHorAdjust;
 
        struct SyncSetMode final : public SyncBase {
                using SyncBase::SyncBase;
                void executeUntil(EmuTime::param time) override {
                        auto& vdp = OUTER(VDP, syncSetMode);
                        vdp.execSetMode(time);
                }
        } syncSetMode;
 
        struct SyncSetBlank final : public SyncBase {
                using SyncBase::SyncBase;
                void executeUntil(EmuTime::param time) override {
                        auto& vdp = OUTER(VDP, syncSetBlank);
                        vdp.execSetBlank(time);
                }
        } syncSetBlank;
 
        struct SyncSetSprites final : public SyncBase {
                using SyncBase::SyncBase;
                void executeUntil(EmuTime::param time) override {
                        auto& vdp = OUTER(VDP, syncSetSprites);
                        vdp.execSetSprites(time);
                }
        } syncSetSprites;
 
        struct SyncCpuVramAccess final : public SyncBase {
                using SyncBase::SyncBase;
                void executeUntil(EmuTime::param time) override {
                        auto& vdp = OUTER(VDP, syncCpuVramAccess);
                        vdp.execCpuVramAccess(time);
                }
        } syncCpuVramAccess;
 
        struct SyncCmdDone final : public SyncBase {
                using SyncBase::SyncBase;
                void executeUntil(EmuTime::param time) override {
                        auto& vdp = OUTER(VDP, syncCmdDone);
                        vdp.execSyncCmdDone(time);
                }
        } syncCmdDone;
 
        void execVSync(EmuTime::param time);
        void execDisplayStart(EmuTime::param time);
        void execVScan(EmuTime::param time);
        void execHScan();
        void execHorAdjust(EmuTime::param time);
        void execSetMode(EmuTime::param time);
        void execSetBlank(EmuTime::param time);
        void execSetSprites(EmuTime::param time);
        void execCpuVramAccess(EmuTime::param time);
        void execSyncCmdDone(EmuTime::param time);
 
        [[nodiscard]] int getVerticalAdjust() const {
                return (controlRegs[18] >> 4) ^ 0x07;
        }
 
        [[nodiscard]] inline bool getHR(int ticksThisFrame) const {
                // Note: These constants are located inside this function because
                //       GCC 4.0.x won't link if they are in the class scope.
                static constexpr int HBLANK_LEN_TXT = 404;
                static constexpr int HBLANK_LEN_GFX = 312;
                return (ticksThisFrame + TICKS_PER_LINE - getRightBorder()) % TICKS_PER_LINE
                     < (displayMode.isTextMode() ? HBLANK_LEN_TXT : HBLANK_LEN_GFX);
        }
 
        // VideoSystemChangeListener interface:
        void preVideoSystemChange() noexcept override;
        void postVideoSystemChange() noexcept override;
 
        void resetInit();
 
        void resetMasks(EmuTime::param time);
 
        void frameStart(EmuTime::param time);
 
        void scheduleDisplayStart(EmuTime::param time);
 
        void scheduleVScan(EmuTime::param time);
 
        void scheduleHScan(EmuTime::param time);
 
        void vramWrite(byte value, EmuTime::param time);
 
        [[nodiscard]] byte vramRead(EmuTime::param time);
 
        void scheduleCpuVramAccess(bool isRead, byte write, EmuTime::param time);
        void executeCpuVramAccess(EmuTime::param time);
 
        [[nodiscard]] byte readStatusReg(byte reg, EmuTime::param time);
 
        void syncAtNextLine(SyncBase& type, EmuTime::param time) const;
 
        void createRenderer();
 
        void updateNameBase(EmuTime::param time);
 
        void updateColorBase(EmuTime::param time);
 
        void updatePatternBase(EmuTime::param time);
 
        void updateSpriteAttributeBase(EmuTime::param time);
 
        void updateSpritePatternBase(EmuTime::param time);
 
        void updateDisplayMode(DisplayMode newMode, bool cmdBit, EmuTime::param time);
 
        // Observer<Setting>
        void update(const Setting& setting) noexcept override;
 
private:
        Display& display;
        EnumSetting<bool>& cmdTiming;
        EnumSetting<bool>& tooFastAccess;
 
        struct RegDebug final : SimpleDebuggable {
                explicit RegDebug(const VDP& vdp);
                [[nodiscard]] byte read(unsigned address) override;
                void write(unsigned address, byte value, EmuTime::param time) override;
        } vdpRegDebug;
 
        struct StatusRegDebug final : SimpleDebuggable {
                explicit StatusRegDebug(const VDP& vdp);
                [[nodiscard]] byte read(unsigned address, EmuTime::param time) override;
        } vdpStatusRegDebug;
 
        struct PaletteDebug final : SimpleDebuggable {
                explicit PaletteDebug(const VDP& vdp);
                [[nodiscard]] byte read(unsigned address) override;
                void write(unsigned address, byte value, EmuTime::param time) override;
        } vdpPaletteDebug;
 
        struct VRAMPointerDebug final : SimpleDebuggable {
                explicit VRAMPointerDebug(const VDP& vdp);
                [[nodiscard]] byte read(unsigned address) override;
                void write(unsigned address, byte value, EmuTime::param time) override;
        } vramPointerDebug;
 
        struct RegisterLatchStatusDebug final : SimpleDebuggable {
                explicit RegisterLatchStatusDebug(const VDP& vdp);
                [[nodiscard]] byte read(unsigned address) override;
        } registerLatchStatusDebug;
 
        struct VramAccessStatusDebug final : SimpleDebuggable {
                explicit VramAccessStatusDebug(const VDP& vdp);
                [[nodiscard]] byte read(unsigned address) override;
        } vramAccessStatusDebug;
 
        struct PaletteLatchStatusDebug final : SimpleDebuggable {
                explicit PaletteLatchStatusDebug(const VDP& vdp);
                [[nodiscard]] byte read(unsigned address) override;
        } paletteLatchStatusDebug;
 
        struct DataLatchDebug final : SimpleDebuggable {
                explicit DataLatchDebug(const VDP& vdp);
                [[nodiscard]] byte read(unsigned address) override;
        } dataLatchDebug;
 
        class Info : public InfoTopic {
        public:
                void execute(std::span<const TclObject> tokens,
                             TclObject& result) const override;
                [[nodiscard]] std::string help(std::span<const TclObject> tokens) const override;
                [[nodiscard]] virtual int calc(const EmuTime& time) const = 0;
        protected:
                Info(VDP& vdp_, const std::string& name, std::string helpText_);
                ~Info() = default;
                VDP& vdp;
                const std::string helpText;
        };
 
        struct FrameCountInfo final : Info {
                explicit FrameCountInfo(VDP& vdp);
                [[nodiscard]] int calc(const EmuTime& time) const override;
        } frameCountInfo;
 
        struct CycleInFrameInfo final : Info {
                explicit CycleInFrameInfo(VDP& vdp);
                [[nodiscard]] int calc(const EmuTime& time) const override;
        } cycleInFrameInfo;
 
        struct LineInFrameInfo final : Info {
                explicit LineInFrameInfo(VDP& vdp);
                [[nodiscard]] int calc(const EmuTime& time) const override;
        } lineInFrameInfo;
 
        struct CycleInLineInfo final : Info {
                explicit CycleInLineInfo(VDP& vdp);
                [[nodiscard]] int calc(const EmuTime& time) const override;
        } cycleInLineInfo;
 
        struct MsxYPosInfo final : Info {
                explicit MsxYPosInfo(VDP& vdp);
                [[nodiscard]] int calc(const EmuTime& time) const override;
        } msxYPosInfo;
 
        struct MsxX256PosInfo final : Info {
                explicit MsxX256PosInfo(VDP& vdp);
                [[nodiscard]] int calc(const EmuTime& time) const override;
        } msxX256PosInfo;
 
        struct MsxX512PosInfo final : Info {
                explicit MsxX512PosInfo(VDP& vdp);
                [[nodiscard]] int calc(const EmuTime& time) const override;
        } msxX512PosInfo;
 
        std::unique_ptr<Renderer> renderer;
 
        std::unique_ptr<VDPCmdEngine> cmdEngine;
 
        std::unique_ptr<SpriteChecker> spriteChecker;
 
        std::unique_ptr<VDPVRAM> vram;
 
        const RawFrame* externalVideo;
 
        const RawFrame* superimposing;
 
        VDPClock frameStartTime;
 
        OptionalIRQHelper irqVertical;
 
        OptionalIRQHelper irqHorizontal;
 
        EmuTime displayStartSyncTime;
 
        EmuTime vScanSyncTime;
 
        EmuTime hScanSyncTime;
 
        TclCallback tooFastCallback;
        TclCallback dotClockDirectionCallback;
 
        VdpVersion version;
 
        int saturationPr;
 
        int saturationPb;
 
        int frameCount;
 
        int displayStart;
 
        int horizontalScanOffset;
 
        int horizontalAdjust;
 
        std::array<byte, 32> controlRegs;
 
        byte controlRegMask;
 
        std::array<byte, 32> controlValueMasks;
 
        int blinkCount;
 
        int vramPointer;
 
        std::array<uint16_t, 16> palette;
 
        bool isDisplayArea;
 
        bool palTiming;
 
        bool interlaced = false;
 
        byte statusReg0;
 
        byte statusReg1;
 
        byte statusReg2;
 
        bool blinkState;
 
        byte dataLatch;
 
        bool writeAccess;
 
        bool registerDataStored;
 
        bool paletteDataStored;
 
        byte cpuVramData;
 
        bool cpuVramReqIsRead;
        bool pendingCpuAccess; // always equal to pendingSyncPoint(CPU_VRAM_ACCESS)
 
        bool cpuExtendedVram;
 
        DisplayMode displayMode;
 
        bool displayEnabled;
 
        bool spriteEnabled;
 
        bool warningPrinted = false;
 
        bool brokenCmdTiming;
        bool allowTooFastAccess;
 
        MSXCPU& cpu;
        const byte fixedVDPIOdelayCycles;
};
SERIALIZE_CLASS_VERSION(VDP, 10);
 
} // namespace openmsx
 
#endif