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 "IRQHelper.hh"
#include "Clock.hh"
#include "DisplayMode.hh"
#include "likely.hh"
#include "openmsx.hh"
#include <memory>

namespace openmsx {

class PostProcessor;
class Renderer;
class VDPCmdEngine;
class VDPVRAM;
class SpriteChecker;
class VDPRegDebug;
class VDPStatusRegDebug;
class VDPPaletteDebug;
class VRAMPointerDebug;
class FrameCountInfo;
class CycleInFrameInfo;
class LineInFrameInfo;
class CycleInLineInfo;
class MsxYPosInfo;
class MsxX256PosInfo;
class MsxX512PosInfo;
class Display;
class RawFrame;
class AccessSlotCalculator;

class VDP : public MSXDevice, public Schedulable,
            private VideoSystemChangeListener
{
public:
        static const int TICKS_PER_SECOND = 3579545 * 6; // 21.5MHz;
        typedef Clock<TICKS_PER_SECOND> VDPClock;

        static const int TICKS_PER_LINE = 1368;

        explicit VDP(const DeviceConfig& config);
        virtual ~VDP();

        virtual void powerUp(EmuTime::param time);
        virtual void reset(EmuTime::param time);
        virtual byte readIO(word port, EmuTime::param time);
        virtual byte peekIO(word port, EmuTime::param time) const;
        virtual void writeIO(word port, byte value, EmuTime::param time);
        virtual void executeUntil(EmuTime::param time, int userData);

        PostProcessor* getPostProcessor() const;

        inline bool isMSX1VDP() const {
                return version == TMS99X8A || version == TMS9929A;
        }

        inline bool hasYJK() const {
                return version == V9958;
        }

        inline DisplayMode getDisplayMode() const {
                return displayMode;
        }

        inline VDPVRAM& getVRAM() {
                return *vram;
        }

        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;
        }

        inline SpriteChecker& getSpriteChecker() {
                return *spriteChecker;
        }

        inline bool getTransparency() const {
                return (controlRegs[8] & 0x20) == 0;
        }

        inline int getForegroundColor() const {
                return controlRegs[7] >> 4;
        }

        inline int getBackgroundColor() const {
                byte reg7 = controlRegs[7];
                if (displayMode.getByte() == DisplayMode::GRAPHIC7) {
                        return reg7;
                } else {
                        return reg7 & 0x0F;
                }
        }

        inline int getBlinkForegroundColor() const {
                return controlRegs[12] >> 4;
        }

        inline int getBlinkBackgroundColor() const {
                return controlRegs[12] & 0x0F;
        }

        inline bool getBlinkState() const {
                return blinkState;
        }

        inline word getPalette(int index) const {
                return palette[index];
        }

        inline bool isDisplayEnabled() const {
                return isDisplayArea && displayEnabled;
        }

        inline bool spritesEnabled() const {
                return displayEnabled && !displayMode.isTextMode() &&
                       ((controlRegs[8] & 0x02) == 0x00);
        }

        inline bool spritesEnabledFast() const {
                assert(!displayMode.isTextMode());
                return displayEnabled && ((controlRegs[8] & 0x02) == 0x00);
        }

        inline byte getVerticalScroll() const {
                return controlRegs[23];
        }

        inline byte getHorizontalScrollLow() const {
                return controlRegs[27];
        }

        inline byte getHorizontalScrollHigh() const {
                return controlRegs[26];
        }

        inline bool isBorderMasked() const {
                return (controlRegs[25] & 0x02) != 0;
        }

        inline bool isMultiPageScrolling() const {
                return (controlRegs[25] & 0x01) && (controlRegs[2] & 0x20);
        }

        inline int getLineZero() const {
                return displayStart / TICKS_PER_LINE;
        }

        inline bool isPalTiming() const {
                return palTiming;
        }

        inline bool isInterlaced() const {
                return interlaced;
        }

        inline bool isEvenOddEnabled() const {
                return (controlRegs[9] & 4) != 0;
        }

        inline bool getEvenOdd() const {
                return (statusReg2 & 2) != 0;
        }

        inline int getEvenOddMask() const {
                // TODO: Verify which page is displayed on even fields.
                return (((~controlRegs[9] & 4) << 6) | ((statusReg2 & 2) << 7)) &
                       (!blinkState << 8);
        }

        inline int getTicksThisFrame(EmuTime::param time) const {
                return frameStartTime.getTicksTill_fast(time);
        }

        inline EmuTime::param getFrameStartTime() const {
                return frameStartTime.getTime();
        }

        inline int getSpriteSize() const {
                return ((controlRegs[1] & 2) << 2) + 8;
        }

        inline bool isSpriteMag() const {
                return controlRegs[1] & 1;
        }

        inline bool getCmdBit() const {
                return (controlRegs[25] & 0x40) != 0;
        }

        inline int getTicksPerFrame() const {
                return palTiming ? TICKS_PER_LINE * 313 : TICKS_PER_LINE * 262;
        }

        inline bool isInsideFrame(EmuTime::param time) const {
                return time >= frameStartTime.getTime() &&
                        getTicksThisFrame(time) <= getTicksPerFrame();
        }

        inline int getLeftSprites() const {
                return 100 + 102 + 56
                        + (horizontalAdjust - 7) * 4
                        + (displayMode.isTextMode() ? 36 : 0);
        }

        inline int getLeftBorder() const {
                return getLeftSprites() + (isBorderMasked() ? 8 * 4 : 0);
        }

        inline int getRightBorder() const {
                return getLeftSprites()
                        + (displayMode.isTextMode() ? 960 : 1024);
        }

        inline int getLeftBackground() const {
                return getLeftSprites() + getHorizontalScrollLow() * 4;
        }

        byte getStatusReg0() const { return statusReg0; }

        void setSpriteStatus(byte value)
        {
                statusReg0 = (statusReg0 & 0x80) | (value & 0x7F);
        }

        bool getVRMode() const {
                return (controlRegs[8] & 8) != 0;
        }

        void setExternalVideoSource(const RawFrame* externalSource);

        EmuTime getAccessSlot(EmuTime::param time, unsigned delta) const;

        AccessSlotCalculator getAccessSlotCalculator(EmuTime::param time) const;

        bool cpuAccessScheduled() const;

        template<typename Archive>
        void serialize(Archive& ar, unsigned version);

private:
        enum VdpVersion {
                TMS99X8A,
                TMS9929A,
                V9938,
                V9958
        };

        enum SyncType {
                VSYNC,
                DISPLAY_START,
                VSCAN,
                HSCAN,
                HOR_ADJUST,
                SET_MODE,
                SET_BLANK,
                CPU_VRAM_ACCESS,
        };

        static const int LINE_COUNT_RESET_TICKS = 15 * TICKS_PER_LINE;

        inline int getNumberOfLines() const {
                return controlRegs[9] & 0x80 ? 212 : 192;
        }

        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 const int HBLANK_LEN_TXT = 404;
                static const int HBLANK_LEN_GFX = 312;
                return
                        ( ticksThisFrame + TICKS_PER_LINE - getRightBorder()
                                ) % TICKS_PER_LINE
                        < (displayMode.isTextMode() ? HBLANK_LEN_TXT : HBLANK_LEN_GFX);
        }

        // VideoSystemChangeListener interface:
        virtual void preVideoSystemChange();
        virtual void postVideoSystemChange();

        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);

        byte vramRead(EmuTime::param time);

        void scheduleCpuVramAccess(bool isRead, EmuTime::param time);
        void executeCpuVramAccess(EmuTime::param time);

        byte peekStatusReg(byte reg, EmuTime::param time) const;
        byte readStatusReg(byte reg, EmuTime::param time);

        void changeRegister(byte reg, byte val, EmuTime::param time);

        void syncAtNextLine(SyncType type, EmuTime::param time);

        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, EmuTime::param time);

        void setPalette(int index, word grb, EmuTime::param time);

private:
        Display& display;

        friend class VDPRegDebug;
        friend class VDPStatusRegDebug;
        friend class VDPPaletteDebug;
        friend class VRAMPointerDebug;
        friend class FrameCountInfo;
        const std::unique_ptr<VDPRegDebug>       vdpRegDebug;
        const std::unique_ptr<VDPStatusRegDebug> vdpStatusRegDebug;
        const std::unique_ptr<VDPPaletteDebug>   vdpPaletteDebug;
        const std::unique_ptr<VRAMPointerDebug>  vramPointerDebug;
        const std::unique_ptr<FrameCountInfo>    frameCountInfo;
        const std::unique_ptr<CycleInFrameInfo>  cycleInFrameInfo;
        const std::unique_ptr<LineInFrameInfo>   lineInFrameInfo;
        const std::unique_ptr<CycleInLineInfo>   cycleInLineInfo;
        const std::unique_ptr<MsxYPosInfo>       msxYPosInfo;
        const std::unique_ptr<MsxX256PosInfo>    msxX256PosInfo;
        const std::unique_ptr<MsxX512PosInfo>    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;

        IRQHelper irqVertical;

        IRQHelper irqHorizontal;

        EmuTime displayStartSyncTime;

        EmuTime vScanSyncTime;

        EmuTime hScanSyncTime;

        VdpVersion version;

        int frameCount;

        int displayStart;

        int horizontalScanOffset;

        int horizontalAdjust;

        byte controlRegs[32];

        int controlRegMask;

        byte controlValueMasks[32];

        int blinkCount;

        int vramPointer;

        word palette[16];

        bool isDisplayArea;

        bool palTiming;

        bool interlaced;

        byte statusReg0;

        byte statusReg1;

        byte statusReg2;

        bool blinkState;

        byte dataLatch;

        bool registerDataStored;

        bool paletteDataStored;

        byte cpuVramData;

        bool cpuVramReqIsRead;

        bool cpuExtendedVram;

        DisplayMode displayMode;

        bool displayEnabled;

        bool warningPrinted;
};
SERIALIZE_CLASS_VERSION(VDP, 5);


class AccessSlotCalculator
{
public:
        AccessSlotCalculator(unsigned ticks_, const unsigned* tab, unsigned tabLen_)
                : ticks(ticks_), tabLen(tabLen_)
        {
                // Search largest value that is smaller or equal to ticks.
                // This could be outside the table boundaries (one element
                // in front), but that's ok because it won't be dereferenced.
                idx = std::upper_bound(tab, tab + tabLen, ticks) - 1;
                assert((idx < tab) || (*idx <= ticks));
        }
        inline EmuDuration getNext(unsigned delta) {
                assert(delta != 0);
                assert(delta <= 136);
                auto stop = ticks + delta;
                do { ++idx; } while (*idx < stop);
                auto duration = VDP::VDPClock::duration(*idx - ticks);
                if (unlikely(*idx >= 1368)) idx -= tabLen;
                ticks = *idx;
                return duration;
        }
private:
        // Usually *idx == ticks, but in case the VDP switched mode
        // in the middle of a command (e.g. enabled/disabled sprites)
        // this may not be the case. So we need both vars.
        const unsigned* idx;
        unsigned ticks;
        const unsigned tabLen;
};


} // namespace openmsx

#endif