VDPAccessSlots.hh

Go to the documentation of this file.

#ifndef VDPACCESSSLOTS_HH
#define VDPACCESSSLOTS_HH
 
#include "VDP.hh"
#include "narrow.hh"
#include <cassert>
#include <cstdint>
#include <span>
 
namespace openmsx::VDPAccessSlots {
 
inline constexpr int TICKS = VDP::TICKS_PER_LINE;
 
enum class Delta : int {
        D0    =  0 * TICKS,
        D1    =  1 * TICKS,
        D16   =  2 * TICKS,
        D24   =  3 * TICKS,
        D28   =  4 * TICKS,
        D32   =  5 * TICKS,
        D40   =  6 * TICKS,
        D48   =  7 * TICKS,
        D64   =  8 * TICKS,
        D72   =  9 * TICKS,
        D88   = 10 * TICKS,
        D104  = 11 * TICKS,
        D120  = 12 * TICKS,
        D128  = 13 * TICKS,
        D136  = 14 * TICKS,
};
static constexpr int NUM_DELTAS = 15;
 
class Calculator
{
public:
        Calculator(EmuTime::param frame, EmuTime::param time,
                   EmuTime::param limit_, std::span<const uint8_t, NUM_DELTAS * TICKS> tab_)
                : ref(frame), tab(tab_)
        {
                assert(frame <= time);
                assert(frame <= limit_);
                // not required that time <= limit
 
                ticks = narrow<int>(ref.getTicksTill_fast(time));
                limit = narrow<int>(ref.getTicksTill_fast(limit_));
                int lines = ticks / TICKS;
                ticks -= lines * TICKS;
                limit -= lines * TICKS; // might be negative
                ref   += lines * TICKS;
                assert(0 <= ticks); assert(ticks < TICKS);
        }
 
        [[nodiscard]] inline bool limitReached() const {
                return ticks >= limit;
        }
 
        [[nodiscard]] inline EmuTime getTime() const {
                return ref.getFastAdd(ticks);
        }
 
        inline void next(Delta delta) {
                ticks += tab[to_underlying(delta) + ticks];
                if (ticks >= TICKS) [[unlikely]] {
                        ticks -= TICKS;
                        limit -= TICKS;
                        ref   += TICKS;
                }
        }
 
private:
        int ticks;
        int limit;
        VDP::VDPClock ref;
        std::span<const uint8_t, NUM_DELTAS * TICKS> tab;
};
 
[[nodiscard]] EmuTime getAccessSlot(EmuTime::param frame, EmuTime::param time, Delta delta,
                      const VDP& vdp);
 
[[nodiscard]] Calculator getCalculator(
        EmuTime::param frame, EmuTime::param time, EmuTime::param limit,
        const VDP& vdp);
 
} // namespace openmsx::VDPAccessSlots
 
#endif