Implement cursor blink

Author: Stovent

benchmarks/benchmarkRenderers.cpp

@@ -25,7 +25,7 @@ static void benchmarkRenderer(std::string_view name)
     renderer.m_codingMethod[B] = CODINGB;
     renderer.m_bps[A] = BPS;
     renderer.m_bps[B] = BPS;
-    renderer.SetDisplayFormat(Video::Renderer::DisplayFormat::PAL);
+    renderer.SetDisplayFormat(Video::Renderer::DisplayFormat::PAL, false);
     renderer.m_mix = true;
 
     uint16_t lineNumber = 0;
@@ -57,7 +57,7 @@ template<typename RENDERER>
 static void benchmarkRendererCursor(std::string_view name)
 {
     RENDERER renderer;
-    renderer.SetDisplayFormat(Video::Renderer::DisplayFormat::PAL);
+    renderer.SetDisplayFormat(Video::Renderer::DisplayFormat::PAL, false);
 
     // Benchmark
     const std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now();

src/CDI/Video/Pixel.hpp

@@ -47,6 +47,11 @@ struct alignas(uint32_t) Pixel
     const ARGB32* AsU32Pointer() const noexcept { return reinterpret_cast<const ARGB32*>(this); }
     ARGB32* AsU32Pointer() noexcept { return reinterpret_cast<ARGB32*>(this); }
 
+    constexpr Pixel Complement() const noexcept
+    {
+        return (~AsU32() & 0x00'FF'FF'FF) | (AsU32() & 0xFF'00'00'00);
+    }
+
     constexpr bool operator==(const Pixel& other) const = default;
 
     constexpr Pixel& operator=(const ARGB32 argb) noexcept

src/CDI/Video/PixelTest.cpp

@@ -18,6 +18,7 @@ static consteval void testPixelStaticAssert()
     static_assert(p.a == 0x11);
     static_assert(p.r == 0x22);
     static_assert(p.g == 0x33);
+    static_assert(p.Complement() == 0x11DDCCBB);
     static_assert(p.b == 0x44);
 
     static_assert((p & 0xF0F0F0F0) == 0x10203040);

src/CDI/Video/Renderer.cpp

@@ -9,20 +9,43 @@ namespace Video
 /** \brief Configures the display format.
  * The input must only be a valid enum value.
  */
-void Renderer::SetDisplayFormat(const DisplayFormat display, const bool highResolution) noexcept
+void Renderer::SetDisplayFormat(const DisplayFormat display, const bool highResolution, bool fps60) noexcept
 {
     if(!isValidDisplayFormat(display))
         panic("Invalid display format {}", static_cast<int>(display));
 
     m_displayFormat = display;
     m_highResolution = highResolution;
+    m_60FPS = fps60;
 }
 
 bool Renderer::isValidDisplayFormat(const DisplayFormat display) noexcept
 {
     return display == DisplayFormat::NTSCMonitor || display == DisplayFormat::NTSCTV || display == DisplayFormat::PAL;
 }
 
+/** \brief Increments the internal time of the cursor blink.
+ * \param ns The time in nanosecond.
+ */
+void Renderer::IncrementCursorTime(const double ns) noexcept
+{
+    if(!m_cursorEnabled || m_cursorBlinkOff == 0)
+        return; // OFF == 0 means ON indefinitely.
+
+    double delta = m_60FPS ? DELTA_60FPS : DELTA_50FPS;
+    if(m_cursorIsOn)
+        delta *= m_cursorBlinkOn;
+    else
+        delta *= m_cursorBlinkOff;
+
+    m_cursorTime += ns;
+    if(m_cursorTime >= delta)
+    {
+        m_cursorTime -= delta;
+        m_cursorIsOn = !m_cursorIsOn;
+    }
+}
+
 /** \brief To be called when the whole frame is drawn.
  * \return The final screen.
  *

src/CDI/Video/Renderer.hpp

@@ -21,10 +21,7 @@ static constexpr bool matteMF(const uint32_t matteCommand) noexcept
  * Every array member with 2 elements means its meant to be index based on the plane number \ref ImagePlane.
  *
  * TODO:
- * - Should the renderer manage the line count and draw itself the final frame and the cursor when reached,
- *   or let it to the user of the renderer with a `Plane RenderFrame();` method ?
  * - V.25/V.26 Pixel repeat on pixel decoding, pixel hold on overlay.
- * - Implement cursor blink.
  * - Should there be a reset method?
  *
  * TODO optimizations:
@@ -80,8 +77,9 @@ class Renderer
     Renderer& operator=(Renderer&&) = delete;
 
     constexpr DisplayFormat GetDisplayFormat() const noexcept { return m_displayFormat; }
-    void SetDisplayFormat(DisplayFormat display, bool highResolution) noexcept;
+    void SetDisplayFormat(DisplayFormat display, bool highResolution, bool fps60) noexcept;
     static bool isValidDisplayFormat(DisplayFormat display) noexcept;
+
     static constexpr uint16_t getDisplayWidth(DisplayFormat display) noexcept
     {
         return display == DisplayFormat::NTSCMonitor ? 360 : 384;
@@ -103,6 +101,7 @@ class Renderer
         return m_screen.m_width == 720;
     }
 
+    void IncrementCursorTime(double ns) noexcept;
     virtual std::pair<uint16_t, uint16_t> DrawLine(const uint8_t* lineA, const uint8_t* lineB, uint16_t lineNumber) noexcept = 0;
     const Plane& RenderFrame() noexcept;
 
@@ -155,7 +154,7 @@ class Renderer
     uint8_t m_cursorColor : 4{}; /**< YRGB color code. */
     std::array<uint16_t, 16> m_cursorPatterns{};
     bool m_cursorBlinkType{}; /**< false is on/off, true is on/complement. */
-    uint8_t m_cursorBlinkOn : 3{}; /**< ON period (zero not allowed). */
+    uint8_t m_cursorBlinkOn : 3{1}; /**< ON period (zero not allowed). */
     uint8_t m_cursorBlinkOff : 3{}; /**< OFF period (if zero, blink is disabled). */
 
     // Image Contribution Factor.
@@ -229,9 +228,16 @@ class Renderer
     };
 
 protected:
+    static constexpr double DELTA_50FPS = 240'000'000.; /**< GB VII.2.3.4.2 GC_Blnk. */
+    static constexpr double DELTA_60FPS = 200'000'000.; /**< GB VII.2.3.4.2 GC_Blnk. */
+
+    double m_cursorTime{0.0}; /**< Keeps track of the emulated time for cursor blink. */
+    bool m_cursorIsOn{true}; /**< Keeps the state of the cursor (ON or OFF/complement). true when ON. */
+
     uint16_t m_lineNumber{}; /**< Current line being drawn, starts at 0. Handled by the caller. */
     DisplayFormat m_displayFormat{DisplayFormat::PAL}; /**< Used to select 360/384 width and 240/280 height. */
     bool m_highResolution{false}; /**< True for 480/560, false for 240/280 pixels height. */
+    bool m_60FPS{false}; /**< False for 50FPS, true for 60FPS. */
 
     virtual void DrawCursor() noexcept = 0;
     void DrawLineBackdrop() noexcept

src/CDI/Video/RendererSIMD.cpp

@@ -130,12 +130,20 @@ void RendererSIMD::DrawCursor() noexcept
     // is outputted continuously line by line).
     // But for here maybe we don't care.
 
-    const Pixel color = backdropCursorColorToPixel(m_cursorColor);
+    Pixel color = backdropCursorColorToPixel(m_cursorColor);
+    if(!m_cursorIsOn)
+    {
+        if(m_cursorBlinkType) // Complement.
+            color = color.Complement();
+        else
+            color = BLACK_PIXEL;
+    }
 
     using SIMDCursorLine = stdx::fixed_size_simd<uint32_t, 16>;
     using SIMDCursorLineMask = SIMDCursorLine::mask_type;
     static constexpr SIMDCursorLine SHIFTER([] (uint32_t i) { return 15 - i; });
 
+    const SIMDCursorLine colorSimd{color.AsU32()};
     int patternIndex = 0;
     for(Plane::iterator dst = m_cursorPlane.begin(); dst < m_cursorPlane.end(); dst += SIMDCursorLine::size(), ++patternIndex)
     {
@@ -145,8 +153,6 @@ void RendererSIMD::DrawCursor() noexcept
         patternSimd &= 1;
         const SIMDCursorLineMask patternMask = patternSimd == 1;
 
-        const SIMDCursorLine colorSimd{color.AsU32()};
-
         SIMDCursorLine cursorPixels = BLACK_PIXEL.AsU32();
         stdx::where(patternMask, cursorPixels) = colorSimd;
         cursorPixels.copy_to(dst->AsU32Pointer(), stdx::element_aligned);

src/CDI/Video/RendererSoftware.cpp

@@ -119,7 +119,14 @@ void RendererSoftware::DrawCursor() noexcept
     // Technically speaking the cursor is drawn when the drawing line number is the cursor's one (because video
     // is outputted continuously line by line).
     // But for here maybe we don't care.
-    const Pixel color = backdropCursorColorToPixel(m_cursorColor);
+    Pixel color = backdropCursorColorToPixel(m_cursorColor);
+    if(!m_cursorIsOn)
+    {
+        if(m_cursorBlinkType) // Complement.
+            color = color.Complement();
+        else
+            color = BLACK_PIXEL;
+    }
 
     Plane::iterator it = m_cursorPlane.begin();
     for(size_t y = 0; y < m_cursorPlane.m_height; ++y)

src/CDI/cores/MCD212/Display.cpp

@@ -28,21 +28,21 @@ void MCD212::DrawVideoLine()
             if(m_lineNumber == 0)
             {
                 m_lineNumber = 1;
-                m_renderer.SetDisplayFormat(GetDisplayFormat(), true);
+                m_renderer.SetDisplayFormat(GetDisplayFormat(), true, Is60FPS());
             }
         }
         else // Odd frames, even lines.
         {
             SetPA();
             if(m_lineNumber == 0)
-                m_renderer.SetDisplayFormat(GetDisplayFormat(), true);
+                m_renderer.SetDisplayFormat(GetDisplayFormat(), true, Is60FPS());
         }
     }
     else // Non-interlaced, PA is always set.
     {
         SetPA();
         if(m_lineNumber == 0)
-            m_renderer.SetDisplayFormat(GetDisplayFormat(), false);
+            m_renderer.SetDisplayFormat(GetDisplayFormat(), false, Is60FPS());
     }
 
     if(GetDE())

src/CDI/cores/MCD212/MCD212.cpp

@@ -46,6 +46,7 @@ void MCD212::IncrementTime(const double ns)
     const size_t lineDisplayTime = GetLineDisplayTime();
     if(m_timeNs >= lineDisplayTime)
     {
+        m_renderer.IncrementCursorTime(m_timeNs);
         DrawVideoLine();
         m_timeNs -= lineDisplayTime;
     }

src/CDI/cores/MCD212/MCD212.hpp

@@ -167,6 +167,11 @@ class MCD212
         return m_isPAL || !GetCF() ? 64000 : 63560;
     }
 
+    bool Is60FPS() const noexcept
+    {
+        return GetFD();
+    }
+
     Video::Renderer::DisplayFormat GetDisplayFormat() const noexcept
     {
         using enum Video::Renderer::DisplayFormat;