V9990.hh

Go to the documentation of this file.

#ifndef V9990_HH
#define V9990_HH
 
#include "MSXDevice.hh"
#include "Schedulable.hh"
#include "TclCallback.hh"
#include "VideoSystemChangeListener.hh"
#include "IRQHelper.hh"
#include "V9990CmdEngine.hh"
#include "V9990DisplayTiming.hh"
#include "V9990ModeEnum.hh"
#include "V9990VRAM.hh"
#include "SimpleDebuggable.hh"
#include "Clock.hh"
#include "narrow.hh"
#include "openmsx.hh"
#include "one_of.hh"
#include "outer.hh"
#include "serialize_meta.hh"
#include "unreachable.hh"
#include <array>
#include <memory>
#include <optional>
 
namespace openmsx {
 
class PostProcessor;
class Display;
class V9990Renderer;
 
class V9990 final : public MSXDevice, private VideoSystemChangeListener
{
public:
        explicit V9990(const DeviceConfig& config);
        ~V9990() override;
 
        // MSXDevice interface:
        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;
 
        [[nodiscard]] PostProcessor* getPostProcessor() const;
 
        [[nodiscard]] inline V9990VRAM& getVRAM() {
                return vram;
        }
 
        [[nodiscard]] inline bool isInterlaced() const {
                return interlaced;
        }
 
        [[nodiscard]] inline bool isEvenOddEnabled() const {
                return (regs[SCREEN_MODE_1] & 0x04) != 0;
        }
 
        [[nodiscard]] inline bool getEvenOdd() const {
                return (status & 0x02) != 0;
        }
 
        [[nodiscard]] inline bool isDisplayEnabled() const {
                return isDisplayArea && displayEnabled;
        }
 
        [[nodiscard]] inline bool spritesEnabled() const {
                return !(regs[CONTROL] & 0x40);
        }
 
        [[nodiscard]] inline byte getPaletteOffset() const {
                return (regs[PALETTE_CONTROL] & 0x0F);
        }
 
        struct GetPaletteResult {
                byte r, g, b;
                bool ys;
        };
        [[nodiscard]] GetPaletteResult getPalette(int index) const;
 
        [[nodiscard]] inline int getUCTicksThisFrame(EmuTime::param time) const {
                return narrow<int>(frameStartTime.getTicksTill_fast(time));
        }
 
        [[nodiscard]] inline bool isPalTiming() const {
                return palTiming;
        }
 
        [[nodiscard]] inline bool isOverScan() const {
                return mode == one_of(V9990DisplayMode::B0, V9990DisplayMode::B2, V9990DisplayMode::B4);
        }
 
        [[nodiscard]] inline bool isSuperimposing() const {
                return superimposing;
        }
 
        void setExternalVideoSource(bool enable) {
                externalVideoSource = enable;
        }
 
        [[nodiscard]] inline unsigned getCursorYOffset() const {
                // TODO vertical set-adjust may or may not influence this,
                //      need to investigate that.
                if (!isOverScan()) return 0;
                return isPalTiming()
                        ? V9990DisplayTiming::displayPAL_MCLK .border1
                        : V9990DisplayTiming::displayNTSC_MCLK.border1;
        }
 
        [[nodiscard]] static inline int UCtoX(int ticks, V9990DisplayMode mode) {
                int x;
                ticks = ticks % V9990DisplayTiming::UC_TICKS_PER_LINE;
                switch (mode) {
                using enum V9990DisplayMode;
                case P1: x = ticks / 8;  break;
                case P2: x = ticks / 4;  break;
                case B0: x = ticks /12;  break;
                case B1: x = ticks / 8;  break;
                case B2: x = ticks / 6;  break;
                case B3: x = ticks / 4;  break;
                case B4: x = ticks / 3;  break;
                case B5: x = 1;          break;
                case B6: x = 1;          break;
                case B7: x = ticks / 2;  break;
                default: x = 1;
                }
                return x;
        }
 
        [[nodiscard]] inline V9990DisplayMode getDisplayMode() const {
                return mode;
        }
 
        V9990ColorMode getColorMode() const;
 
        [[nodiscard]] inline unsigned getColorDepth() const {
                return regs[SCREEN_MODE_0] & 0x03;
        }
 
        [[nodiscard]] inline byte getBackDropColor() const {
                return regs[BACK_DROP_COLOR];
        }
 
        [[nodiscard]] inline unsigned getScrollAX() const {
                return regs[SCROLL_CONTROL_AX0] + 8 * regs[SCROLL_CONTROL_AX1];
        }
 
        [[nodiscard]] inline unsigned getScrollAY() const {
                return regs[SCROLL_CONTROL_AY0] + 256 * scrollAYHigh;
        }
 
        [[nodiscard]] inline unsigned getScrollBX() const {
                return regs[SCROLL_CONTROL_BX0] + 8 * regs[SCROLL_CONTROL_BX1];
        }
 
        [[nodiscard]] inline unsigned getScrollBY() const {
                return regs[SCROLL_CONTROL_BY0] + 256 * scrollBYHigh;
        }
 
        [[nodiscard]] inline unsigned getRollMask(unsigned maxMask) const {
                static std::array<unsigned, 4> rollMasks = {
                        0xFFFF, // no rolling (use maxMask)
                        0x00FF,
                        0x01FF,
                        0x00FF // TODO check this (undocumented)
                };
                unsigned t = regs[SCROLL_CONTROL_AY1] >> 6;
                return t ? rollMasks[t] : maxMask;
        }
 
        [[nodiscard]] inline unsigned getImageWidth() const {
                switch (regs[SCREEN_MODE_0] & 0xC0) {
                case 0x00: // P1
                        return 256;
                case 0x40: // P2
                        return 512;
                case 0x80: // Bx
                default:   // standby TODO check this
                        return (256 << ((regs[SCREEN_MODE_0] & 0x0C) >> 2));
                }
        }
        [[nodiscard]] inline unsigned getLineWidth() const {
                switch (getDisplayMode()) {
                using enum V9990DisplayMode;
                case B0:          return  213;
                case P1: case B1: return  320;
                case B2:          return  426;
                case P2: case B3: return  640;
                case B4:          return  853;
                case B5: case B6: return    1; // not supported
                case B7:          return 1280;
                default:
                        UNREACHABLE;
                }
        }
 
        inline void cmdReady() {
                raiseIRQ(CMD_IRQ);
        }
 
        [[nodiscard]] inline int getSpritePatternAddress(V9990DisplayMode m) const {
                switch (m) {
                case V9990DisplayMode::P1:
                        return (int(regs[SPRITE_PATTERN_ADDRESS] & 0x0E) << 14);
                case V9990DisplayMode::P2:
                        return (int(regs[SPRITE_PATTERN_ADDRESS] & 0x0F) << 15);
                default:
                        return 0;
                }
        }
 
        [[nodiscard]] inline byte getSpritePaletteOffset() const {
                return narrow_cast<byte>(regs[SPRITE_PALETTE_CONTROL] << 2);
        }
 
        [[nodiscard]] inline const V9990DisplayPeriod& getHorizontalTiming() const {
                return *horTiming;
        }
 
        [[nodiscard]] inline int getLeftBorder() const {
                return horTiming->blank + horTiming->border1 +
                       (((regs[DISPLAY_ADJUST] & 0x0F) ^ 7) - 8) * 8;
        }
        [[nodiscard]] inline int getRightBorder() const {
                return getLeftBorder() + horTiming->display;
        }
 
        [[nodiscard]] inline const V9990DisplayPeriod& getVerticalTiming() const {
                return *verTiming;
        }
 
        [[nodiscard]] inline int getTopBorder() const {
                return verTiming->blank + verTiming->border1 +
                       (((regs[DISPLAY_ADJUST] >> 4) ^ 7) - 8);
        }
        [[nodiscard]] inline int getBottomBorder() const {
                return getTopBorder() + verTiming->display;
        }
 
        [[nodiscard]] inline unsigned getPriorityControlX() const {
                unsigned t = regs[PRIORITY_CONTROL] & 0x03;
                return (t == 0) ? 256 : t << 6;
        }
        [[nodiscard]] inline unsigned getPriorityControlY() const {
                unsigned t = regs[PRIORITY_CONTROL] & 0x0C;
                return (t == 0) ? 256 : t << 4;
        }
 
        template<typename Archive>
        void serialize(Archive& ar, unsigned version);
 
private:
        // VideoSystemChangeListener interface:
        void preVideoSystemChange() noexcept override;
        void postVideoSystemChange() noexcept override;
 
        // Scheduler stuff
        struct SyncBase : Schedulable {
                explicit SyncBase(const V9990& v9990) : Schedulable(v9990.getScheduler()) {}
                using Schedulable::setSyncPoint;
                using Schedulable::removeSyncPoint;
        protected:
                ~SyncBase() = default;
        };
 
        struct SyncVSync final : SyncBase {
                using SyncBase::SyncBase;
                void executeUntil(EmuTime::param time) override {
                        auto& v9990 = OUTER(V9990, syncVSync);
                        v9990.execVSync(time);
                }
        } syncVSync;
 
        struct SyncDisplayStart final : SyncBase {
                using SyncBase::SyncBase;
                void executeUntil(EmuTime::param time) override {
                        auto& v9990 = OUTER(V9990, syncDisplayStart);
                        v9990.execDisplayStart(time);
                }
        } syncDisplayStart;
 
        struct SyncVScan final : SyncBase {
                using SyncBase::SyncBase;
                void executeUntil(EmuTime::param time) override {
                        auto& v9990 = OUTER(V9990, syncVScan);
                        v9990.execVScan(time);
                }
        } syncVScan;
 
        struct SyncHScan final : SyncBase {
                using SyncBase::SyncBase;
                void executeUntil(EmuTime::param /*time*/) override {
                        auto& v9990 = OUTER(V9990, syncHScan);
                        v9990.execHScan();
                }
        } syncHScan;
 
        struct SyncSetMode final : SyncBase {
                using SyncBase::SyncBase;
                void executeUntil(EmuTime::param time) override {
                        auto& v9990 = OUTER(V9990, syncSetMode);
                        v9990.execSetMode(time);
                }
        } syncSetMode;
 
        struct SyncCmdEnd final : SyncBase {
                using SyncBase::SyncBase;
                void executeUntil(EmuTime::param time) override {
                        auto& v9990 = OUTER(V9990, syncCmdEnd);
                        v9990.execCheckCmdEnd(time);
                }
        } syncCmdEnd;
 
        void execVSync(EmuTime::param time);
        void execDisplayStart(EmuTime::param time);
        void execVScan(EmuTime::param time);
        void execHScan();
        void execSetMode(EmuTime::param time);
        void execCheckCmdEnd(EmuTime::param time);
 
        // --- types ------------------------------------------------------
 
        enum IRQType : byte {
                VER_IRQ = 1,
                HOR_IRQ = 2,
                CMD_IRQ = 4
        };
 
        enum PortId {
                VRAM_DATA = 0,
                PALETTE_DATA,
                COMMAND_DATA,
                REGISTER_DATA,
                REGISTER_SELECT,
                STATUS,
                INTERRUPT_FLAG,
                SYSTEM_CONTROL,
                KANJI_ROM_0,
                KANJI_ROM_1,
                KANJI_ROM_2,
                KANJI_ROM_3,
                RESERVED_0,
                RESERVED_1,
                RESERVED_2,
                RESERVED_3
        };
 
        enum RegisterId {
                VRAM_WRITE_ADDRESS_0 = 0,
                VRAM_WRITE_ADDRESS_1,
                VRAM_WRITE_ADDRESS_2,
                VRAM_READ_ADDRESS_0,
                VRAM_READ_ADDRESS_1,
                VRAM_READ_ADDRESS_2,
                SCREEN_MODE_0,
                SCREEN_MODE_1,
                CONTROL,
                INTERRUPT_0,
                INTERRUPT_1,
                INTERRUPT_2,
                INTERRUPT_3,
                PALETTE_CONTROL,
                PALETTE_POINTER,
                BACK_DROP_COLOR,
                DISPLAY_ADJUST,
                SCROLL_CONTROL_AY0,
                SCROLL_CONTROL_AY1,
                SCROLL_CONTROL_AX0,
                SCROLL_CONTROL_AX1,
                SCROLL_CONTROL_BY0,
                SCROLL_CONTROL_BY1,
                SCROLL_CONTROL_BX0,
                SCROLL_CONTROL_BX1,
                SPRITE_PATTERN_ADDRESS,
                LCD_CONTROL,
                PRIORITY_CONTROL,
                SPRITE_PALETTE_CONTROL,
                CMD_PARAM_SRC_ADDRESS_0 = 32,
                CMD_PARAM_SRC_ADDRESS_1,
                CMD_PARAM_SRC_ADDRESS_2,
                CMD_PARAM_SRC_ADDRESS_3,
                CMD_PARAM_DEST_ADDRESS_0,
                CMD_PARAM_DEST_ADDRESS_1,
                CMD_PARAM_DEST_ADDRESS_2,
                CMD_PARAM_DEST_ADDRESS_3,
                CMD_PARAM_SIZE_0,
                CMD_PARAM_SIZE_1,
                CMD_PARAM_SIZE_2,
                CMD_PARAM_SIZE_3,
                CMD_PARAM_ARGUMENT,
                CMD_PARAM_LOGOP,
                CMD_PARAM_WRITE_MASK_0,
                CMD_PARAM_WRITE_MASK_1,
                CMD_PARAM_FONT_COLOR_FC0,
                CMD_PARAM_FONT_COLOR_FC1,
                CMD_PARAM_FONT_COLOR_BC0,
                CMD_PARAM_FONT_COLOR_BC1,
                CMD_PARAM_OPCODE,
                CMD_PARAM_BORDER_X_0,
                CMD_PARAM_BORDER_X_1
        };
 
        // --- members ----------------------------------------------------
 
        struct RegDebug final : SimpleDebuggable {
                explicit RegDebug(const V9990& v9990);
                [[nodiscard]] byte read(unsigned address) override;
                void write(unsigned address, byte value, EmuTime::param time) override;
        } v9990RegDebug;
 
        struct PalDebug final : SimpleDebuggable {
                explicit PalDebug(const V9990& v9990);
                [[nodiscard]] byte read(unsigned address) override;
                void write(unsigned address, byte value, EmuTime::param time) override;
        } v9990PalDebug;
 
        IRQHelper irq;
 
        Display& display;
 
        TclCallback   invalidRegisterReadCallback;
        TclCallback   invalidRegisterWriteCallback;
 
        V9990VRAM vram;
        unsigned vramReadPtr, vramWritePtr;
        byte vramReadBuffer;
 
        V9990CmdEngine cmdEngine;
 
        std::unique_ptr<V9990Renderer> renderer;
 
        Clock<V9990DisplayTiming::UC_TICKS_PER_SECOND> frameStartTime;
 
        EmuTime hScanSyncTime;
 
        const V9990DisplayPeriod* horTiming;
        const V9990DisplayPeriod* verTiming;
 
        V9990DisplayMode mode;
 
        std::array<byte, 0x100> palette;
 
        byte status;
 
        byte pendingIRQs = 0;
 
        std::array<byte, 0x40> regs = {}; // fill with zero
        byte regSelect;
 
        bool palTiming{false};
 
        bool interlaced{false};
 
        bool isDisplayArea{false};
 
        bool displayEnabled{false};
 
        byte scrollAYHigh;
        byte scrollBYHigh;
 
        bool systemReset;
 
        bool externalVideoSource{false};
 
        bool superimposing{false};
 
        // --- methods ----------------------------------------------------
 
        void setHorizontalTiming();
        void setVerticalTiming();
 
        [[nodiscard]] V9990ColorMode getColorMode(byte pal_ctrl) const;
 
        [[nodiscard]] inline unsigned getVRAMAddr(RegisterId base) const;
 
        inline void setVRAMAddr(RegisterId base, unsigned addr);
 
        [[nodiscard]] byte readRegister(byte reg, EmuTime::param time) const;
 
        void writeRegister(byte reg, byte val, EmuTime::param time);
 
        void writePaletteRegister(byte reg, byte val, EmuTime::param time);
 
        void syncAtNextLine(SyncBase& type, EmuTime::param time) const;
 
        void createRenderer(EmuTime::param time);
 
        void frameStart(EmuTime::param time);
 
        void raiseIRQ(IRQType irqType);
 
        [[nodiscard]] V9990DisplayMode calcDisplayMode() const;
        void setDisplayMode(V9990DisplayMode newMode);
 
        void scheduleHscan(EmuTime::param time);
 
        void scheduleCmdEnd(EmuTime::param time);
};
SERIALIZE_CLASS_VERSION(V9990, 5);
 
} // namespace openmsx
 
#endif