Renderers fixes

Stovent · Stovent · commit 708636639b9c · 2025-09-21T21:40:52.000-04:00
diff --git a/benchmarks/benchmarkRenderers.cpp b/benchmarks/benchmarkRenderers.cpp
@@ -78,30 +78,36 @@ static void benchmarkRendererCursor(std::string_view name)
     );
 }
 
+#if LIBCEDIMU_ENABLE_RENDERERSIMD
+#define IF_SIMD(code) code
+#else
+#define IF_SIMD(code)
+#endif
+
 int main()
 {
     constexpr Video::Renderer::BitsPerPixel NORMAL_8 = Video::Renderer::BitsPerPixel::Normal8;
     constexpr Video::Renderer::BitsPerPixel DOUBLE_4 = Video::Renderer::BitsPerPixel::Double4;
     // constexpr Video::Renderer::BitsPerPixel HIGH_8 = Video::Renderer::BitsPerPixel::High8;
 
     benchmarkRendererCursor<Video::RendererSoftware>("Cursor Soft");
-    benchmarkRendererCursor<Video::RendererSIMD>("Cursor SIMD");
+    IF_SIMD(benchmarkRendererCursor<Video::RendererSIMD>("Cursor SIMD"));
 
     benchmarkRenderer<Video::RendererSoftware, NORMAL_8, ICM(OFF), ICM(RGB555)>("Normal Soft RGB555");
-    benchmarkRenderer<Video::RendererSIMD, NORMAL_8, ICM(OFF), ICM(RGB555)>("Normal SIMD RGB555");
+    IF_SIMD((benchmarkRenderer<Video::RendererSIMD, NORMAL_8, ICM(OFF), ICM(RGB555)>("Normal SIMD RGB555")));
 
     benchmarkRenderer<Video::RendererSoftware, NORMAL_8, ICM(DYUV), ICM(DYUV)>("Normal Soft DYUV");
-    benchmarkRenderer<Video::RendererSIMD, NORMAL_8, ICM(DYUV), ICM(DYUV)>("Normal SIMD DYUV");
+    IF_SIMD((benchmarkRenderer<Video::RendererSIMD, NORMAL_8, ICM(DYUV), ICM(DYUV)>("Normal SIMD DYUV")));
 
     benchmarkRenderer<Video::RendererSoftware, DOUBLE_4, ICM(DYUV), ICM(DYUV)>("Double Soft DYUV");
-    benchmarkRenderer<Video::RendererSIMD, DOUBLE_4, ICM(DYUV), ICM(DYUV)>("Double SIMD DYUV");
+    IF_SIMD((benchmarkRenderer<Video::RendererSIMD, DOUBLE_4, ICM(DYUV), ICM(DYUV)>("Double SIMD DYUV")));
 
     benchmarkRenderer<Video::RendererSoftware, DOUBLE_4, ICM(CLUT4), ICM(CLUT4)>("Double Soft CLUT4");
-    benchmarkRenderer<Video::RendererSIMD, DOUBLE_4, ICM(CLUT4), ICM(CLUT4)>("Double SIMD CLUT4");
+    IF_SIMD((benchmarkRenderer<Video::RendererSIMD, DOUBLE_4, ICM(CLUT4), ICM(CLUT4)>("Double SIMD CLUT4")));
 
     benchmarkRenderer<Video::RendererSoftware, NORMAL_8, ICM(CLUT8), ICM(CLUT7)>("Normal Soft CLUT8/CLUT7");
-    benchmarkRenderer<Video::RendererSIMD, NORMAL_8, ICM(CLUT8), ICM(CLUT7)>("Normal SIMD CLUT8/CLUT7");
+    IF_SIMD((benchmarkRenderer<Video::RendererSIMD, NORMAL_8, ICM(CLUT8), ICM(CLUT7)>("Normal SIMD CLUT8/CLUT7")));
 
     benchmarkRenderer<Video::RendererSoftware, DOUBLE_4, ICM(CLUT8), ICM(CLUT7)>("Double Soft CLUT8/CLUT7");
-    benchmarkRenderer<Video::RendererSIMD, DOUBLE_4, ICM(CLUT8), ICM(CLUT7)>("Double SIMD CLUT8/CLUT7");
+    IF_SIMD((benchmarkRenderer<Video::RendererSIMD, DOUBLE_4, ICM(CLUT8), ICM(CLUT7)>("Double SIMD CLUT8/CLUT7")));
 }
diff --git a/benchmarks/benchmarkVideoDecoders.cpp b/benchmarks/benchmarkVideoDecoders.cpp
@@ -138,14 +138,20 @@ static void benchmarkRunLength(std::string_view name, const uint8_t* data)
     );
 }
 
+#if LIBCEDIMU_ENABLE_RENDERERSIMD
+#define IF_SIMD(code) code
+#else
+#define IF_SIMD(code)
+#endif
+
 int main()
 {
     benchmarkRGB555Line<Video::decodeRGB555Line<HALF_WIDTH>>("RGB555 Soft");
-    benchmarkRGB555Line<Video::decodeRGB555LineSIMD<HALF_WIDTH>>("RGB555 SIMD");
+    IF_SIMD(benchmarkRGB555Line<Video::decodeRGB555LineSIMD<HALF_WIDTH>>("RGB555 SIMD"));
 
     benchmarkDYUVLine<Video::decodeDYUVLine<HALF_WIDTH>>("DYUV Soft");
     benchmarkDYUVLine<Video::decodeDYUVLineLUT<HALF_WIDTH>>("DYUV  LUT");
-    benchmarkDYUVLine<Video::decodeDYUVLineSIMD<HALF_WIDTH>>("DYUV SIMD");
+    IF_SIMD(benchmarkDYUVLine<Video::decodeDYUVLineSIMD<HALF_WIDTH>>("DYUV SIMD"));
 
     benchmarkCLUTLine<Video::decodeCLUTLine<WIDTH>>("CLUT Soft");
 
diff --git a/src/CDI/Video/Renderer.cpp b/src/CDI/Video/Renderer.cpp
@@ -30,7 +30,10 @@ bool Renderer::isValidDisplayFormat(const DisplayFormat display) noexcept
 void Renderer::IncrementCursorTime(const double ns) noexcept
 {
     if(!m_cursorEnabled || m_cursorBlinkOff == 0)
+    {
+        m_cursorIsOn = true; // Reset to true if blink is disabled during the off/complement pattern.
         return; // OFF == 0 means ON indefinitely.
+    }
 
     double delta = m_60FPS ? DELTA_60FPS : DELTA_50FPS;
     if(m_cursorIsOn)
@@ -133,10 +136,10 @@ bool Renderer::isAllowedImageCodingCombination(ImageCodingMethod planeA, ImageCo
     if(planeB == RGB555 && planeA != OFF)
         return false;
 
-    if((planeA == CLUT8 || planeA == CLUT77) && planeB != DYUV)
+    if((planeA == CLUT8 || planeA == CLUT77) && (planeB != DYUV && planeB != OFF))
         return false;
 
-    // If I implement QHY, if(planeB == QHY && planeA != DYUV) return false;
+    // If I implement QHY, if(planeB == QHY && (planeA != DYUV && planeA != OFF)) return false;
     return true;
 }
 
diff --git a/src/CDI/Video/RendererDCP.cpp b/src/CDI/Video/RendererDCP.cpp
@@ -117,11 +117,26 @@ bool Renderer::ExecuteDCPInstruction(const uint32_t instruction) noexcept
         return false;
     }
 
-    if constexpr(PLANE == A) // Plane A-only instructions.
+    // Common instructions.
+    switch(code)
     {
-        switch(code)
+    case NoOperation:
+    case LoadControlTableLineStartPointer: // Avoid going in the default case.
+    case LoadDisplayLineStartPointer:
+        break;
+
+    case SignalScanLine: // Signal when scan reaches this line.
+        return true;
+
+    case LoadDisplayParameters: // Load display parameters.
+        m_imageType[PLANE] = decodeImageType(bits<0, 1>(instruction));
+        m_pixelRepeatFactor[PLANE] = 1 << (1 + bits<2, 3>(instruction));
+        m_bps[PLANE] = decodeBitsPerPixel(bits<8, 9>(instruction));
+        break;
+
+    case SelectImageCodingMethod: // Select image coding methods.
+        if constexpr(PLANE == A)
         {
-        case SelectImageCodingMethod: // Select image coding methods.
             m_clutSelectHigh = bit<22>(instruction);
             m_matteNumber = bit<19>(instruction);
             m_codingMethod[B] = decodeCodingMethod1(bits<8, 11>(instruction));
@@ -131,91 +146,87 @@ bool Renderer::ExecuteDCPInstruction(const uint32_t instruction) noexcept
                     static_cast<int>(m_codingMethod[A]), static_cast<int>(m_codingMethod[B]));
             // TODO: what to do with external video enabled?
             m_externalVideo = bit<18>(instruction);
-            return false;
+        }
+        return false;
 
-        case LoadTransparencyControl: // Load transparency control information.
+    case LoadTransparencyControl: // Load transparency control information.
+        if constexpr(PLANE == A)
+        {
             m_mix = !bit<23>(instruction);
             m_transparencyControl[B] = bits<8, 11>(instruction);
             m_transparencyControl[A] = bits<0, 3>(instruction);
-            return false;
+        }
+        return false;
 
-        case LoadPlaneOrder: // Load plane order.
+    case LoadPlaneOrder: // Load plane order.
+        if constexpr(PLANE == A)
             m_planeOrder = bit<0>(instruction);
-            return false;
+        return false;
+
+    case SetCLUTBank: // Set CLUT bank.
+        m_clutBank = bits<0, 1>(instruction);
+        break;
 
-        case LoadTransparentColorA: // Load transparent color for plane A.
+    case LoadTransparentColorA: // Load transparent color for plane A.
+        if constexpr(PLANE == A)
             m_transparentColorRgb[A] = dcpExtractCommand(instruction);
-            return false;
+        return false;
+
+    case LoadTransparentColorB: // Load transparent color for plane B.
+        if constexpr(PLANE == B)
+            m_transparentColorRgb[B] = dcpExtractCommand(instruction);
+        return false;
 
-        case LoadMaskColorA: // Load mask color for plane A.
+    case LoadMaskColorA: // Load mask color for plane A.
+        if constexpr(PLANE == A)
             m_maskColorRgb[A] = dcpExtractCommand(instruction);
-            return false;
+        return false;
 
-        case LoadDYUVStartValueA: // Load DYUV start value for plane A.
+    case LoadMaskColorB: // Load mask color for plane B.
+        if constexpr(PLANE == B)
+            m_maskColorRgb[B] = dcpExtractCommand(instruction);
+        return false;
+
+    case LoadDYUVStartValueA: // Load DYUV start value for plane A.
+        if constexpr(PLANE == A)
             m_dyuvInitialValue[A] = dcpExtractCommand(instruction);
-            return false;
+        return false;
 
-        case LoadBackdropColor: // Load backdrop color.
+    case LoadDYUVStartValueB: // Load DYUV start value for plane B.
+        if constexpr(PLANE == B)
+            m_dyuvInitialValue[B] = dcpExtractCommand(instruction);
+        return false;
+
+    case LoadBackdropColor: // Load backdrop color.
+        if constexpr(PLANE == A)
             m_backdropColor = bits<0, 3>(instruction);
-            return false;
+        return false;
 
-        case LoadMosaicFactorA: // Load mosaic pixel hold factor for A.
+    case LoadMosaicFactorA: // Load mosaic pixel hold factor for A.
+        if constexpr(PLANE == A)
+        {
             m_holdEnabled[A] = bit<23>(instruction);
             m_holdFactor[A] = instruction;
-            return false;
-
-        case LoadImageContributionFactorA: // Load image contribution factor for A.
-            m_icf[A] = bits<0, 5>(instruction);
-            return false;
         }
-    }
-    else // Plane B-only instructions.
-    {
-        switch(code)
-        {
-        case LoadTransparentColorB: // Load transparent color for plane B.
-            m_transparentColorRgb[B] = dcpExtractCommand(instruction);
-            return false;
-
-        case LoadMaskColorB: // Load mask color for plane B.
-            m_maskColorRgb[B] = dcpExtractCommand(instruction);
-            return false;
-
-        case LoadDYUVStartValueB: // Load DYUV start value for plane B.
-            m_dyuvInitialValue[B] = dcpExtractCommand(instruction);
-            return false;
+        return false;
 
-        case LoadMosaicFactorB: // Load mosaic pixel hold factor for B.
+    case LoadMosaicFactorB: // Load mosaic pixel hold factor for B.
+        if constexpr(PLANE == B)
+        {
             m_holdEnabled[B] = bit<23>(instruction);
             m_holdFactor[B] = instruction;
-            return false;
-
-        case LoadImageContributionFactorB: // Load image contribution factor for B.
-            m_icf[B] = bits<0, 5>(instruction);
-            return false;
         }
-    }
-
-    // Common instructions.
-    switch(code)
-    {
-    case NoOperation:
-    case LoadControlTableLineStartPointer: // Avoid going in the default case.
-    case LoadDisplayLineStartPointer:
-        break;
-
-    case SignalScanLine: // Signal when scan reaches this line.
-        return true;
+        return false;
 
-    case LoadDisplayParameters: // Load display parameters.
-        m_imageType[PLANE] = decodeImageType(bits<0, 1>(instruction));
-        m_pixelRepeatFactor[PLANE] = 1 << (1 + bits<2, 3>(instruction));
-        m_bps[PLANE] = decodeBitsPerPixel(bits<8, 9>(instruction));
-        break;
+    case LoadImageContributionFactorA: // Load image contribution factor for A.
+        if constexpr(PLANE == A)
+            m_icf[A] = bits<0, 5>(instruction);
+        return false;
 
-    case SetCLUTBank: // Set CLUT bank.
-        m_clutBank = bits<0, 1>(instruction);
-        break;
+    case LoadImageContributionFactorB: // Load image contribution factor for B.
+        if constexpr(PLANE == B)
+            m_icf[B] = bits<0, 5>(instruction);
+        return false;
 
     default:
         std::println(stderr, "Unknow DCP instruction {:#X}", instruction);
diff --git a/src/CDI/Video/RendererSIMD.cpp b/src/CDI/Video/RendererSIMD.cpp
@@ -39,13 +39,15 @@ std::pair<uint16_t, uint16_t> RendererSIMD::DrawLine(const uint8_t* lineA, const
         uint16_t height = GetDisplayHeight();
 
         m_screen.m_width = m_plane[A].m_width = m_plane[B].m_width = width * 2;
-        m_screen.m_height = m_plane[A].m_height = m_plane[B].m_height = height;
+        m_screen.m_height = m_plane[A].m_height = m_plane[B].m_height = m_backdropPlane.m_height = height;
     }
 
     ResetMatte();
 
-    const uint16_t bytesA = DrawLinePlane<A>(lineA, nullptr); // nullptr because plane A can't decode RGB555.
+    uint16_t bytesA = DrawLinePlane<A>(lineA, nullptr); // nullptr because plane A can't decode RGB555.
     const uint16_t bytesB = DrawLinePlane<B>(lineB, lineA);
+    if(m_codingMethod[B] == ImageCodingMethod::RGB555)
+        bytesA = bytesB;
 
     DrawLineBackdrop();
 
@@ -196,7 +198,7 @@ static inline constexpr SIMDNativePixel ALPHA_MASKK{0xFF'00'00'00};
  * \tparam SIMD The SIMD type holding signed 32 bits integers.
  */
 template<typename SIMD>
-static constexpr void applyICFMixSIMDShift(Pixel* screen, const Pixel* planeFront, const Pixel* planeBack, const uint8_t* icfFront, const uint8_t* icfBack) noexcept
+static constexpr void applyICFMixSIMDShift(Pixel* screen, const Pixel* planeFront, const Pixel* planeBack, const uint8_t* icfFront, const uint8_t* icfBack, const uint32_t backdrop) noexcept
 {
     SIMD icfF{icfFront, stdx::element_aligned};
     SIMD icfB{icfBack, stdx::element_aligned};
@@ -267,6 +269,7 @@ static constexpr void applyICFMixSIMDShift(Pixel* screen, const Pixel* planeFron
     bfp = stdx::clamp(bfp, U8_MIN, U8_MAX);
 
     const SIMD result = (rfp << 16) | (gfp << 8) | bfp;
+    stdx::where(maskF && maskB, result) = backdrop;
 
     result.copy_to(screen->AsU32Pointer(), stdx::element_aligned);
 }
@@ -276,7 +279,7 @@ static constexpr void applyICFMixSIMDShift(Pixel* screen, const Pixel* planeFron
 /** \brief Applies ICF and mixes using SIMD (algorithm that casts the registers to access RGB components).
  * This can't be used with fixed-sized SIMD because fixed_sized_simd is not trivially copyable.
  */
-static constexpr void applyICFMixSIMDCast(Pixel* screen, const Pixel* planeFront, const Pixel* planeBack, const uint8_t* icfFront, const uint8_t* icfBack) noexcept
+static constexpr void applyICFMixSIMDCast(Pixel* screen, const Pixel* planeFront, const Pixel* planeBack, const uint8_t* icfFront, const uint8_t* icfBack, const uint32_t backdrop) noexcept
 {
     SIMDNativePixel icfF{icfFront, stdx::element_aligned};
     SIMDNativePixel icfB{icfBack, stdx::element_aligned};
@@ -322,13 +325,14 @@ static constexpr void applyICFMixSIMDCast(Pixel* screen, const Pixel* planeFront
     // rgbB16 >>= 6;
 
     rgbF16 += 16;
-    // rgbB16 += 16; Don't add 16 to back plane when applying ICF because the below mixing subtracts it.
+    // Don't add 16 to back plane when applying ICF because the below mixing subtracts it.
 
     rgbF16 += rgbB16;
 
     rgbF16 = stdx::clamp(rgbF16, U8_MINN, U8_MAXX);
 
-    const SIMDNativePixel result = std::bit_cast<SIMDNativePixel>(stdx::static_simd_cast<SIMDNativeU8>(rgbF16));
+    SIMDNativePixel result = std::bit_cast<SIMDNativePixel>(stdx::static_simd_cast<SIMDNativeU8>(rgbF16));
+    stdx::where(maskF && maskB, result) = backdrop;
 
     result.copy_to(screen->AsU32Pointer(), stdx::element_aligned);
 }
@@ -506,7 +510,7 @@ void RendererSIMD::HandleOverlayMixSIMD() noexcept
         planeFront += SIMD_SIZE, planeBack += SIMD_SIZE, icfFront += SIMD_SIZE, icfBack += SIMD_SIZE, screen += SIMD_SIZE)
     {
         if constexpr(MIX) // Mixing.
-            applyICFMixSIMDCast(screen, planeFront, planeBack, icfFront, icfBack);
+            applyICFMixSIMDCast(screen, planeFront, planeBack, icfFront, icfBack, m_backdropPlane.GetLinePointer(m_lineNumber)->AsU32());
             // applyICFMixSIMDShift<SIMDNativePixelSigned>(screen, planeFront, planeBack, icfFront, icfBack);
         else // Overlay.
             applyICFOverlaySIMDCast(screen, planeFront, planeBack, icfFront, icfBack, m_backdropPlane.GetLinePointer(m_lineNumber)->AsU32());
@@ -517,7 +521,7 @@ void RendererSIMD::HandleOverlayMixSIMD() noexcept
     {
         // Now the remaining width is less than a SIMD register.
         if constexpr(MIX)
-            applyICFMixSIMDShift<SIMDFixedPixelSigned<WIDTH_REMINDER>>(screen, planeFront, planeBack, icfFront, icfBack);
+            applyICFMixSIMDShift<SIMDFixedPixelSigned<WIDTH_REMINDER>>(screen, planeFront, planeBack, icfFront, icfBack, m_backdropPlane.GetLinePointer(m_lineNumber)->AsU32());
         else
             applyICFOverlaySIMDShift<SIMDFixedPixelSigned<WIDTH_REMINDER>>(screen, planeFront, planeBack, icfFront, icfBack, m_backdropPlane.GetLinePointer(m_lineNumber)->AsU32());
     }
diff --git a/src/CDI/Video/RendererSoftware.cpp b/src/CDI/Video/RendererSoftware.cpp
@@ -28,13 +28,15 @@ std::pair<uint16_t, uint16_t> RendererSoftware::DrawLine(const uint8_t* lineA, c
         uint16_t height = GetDisplayHeight();
 
         m_screen.m_width = m_plane[A].m_width = m_plane[B].m_width = width * 2;
-        m_screen.m_height = m_plane[A].m_height = m_plane[B].m_height = height;
+        m_screen.m_height = m_plane[A].m_height = m_plane[B].m_height = m_backdropPlane.m_height = height;
     }
 
     ResetMatte();
 
-    const uint16_t bytesA = DrawLinePlane<A>(lineA, nullptr); // nullptr because plane A can't decode RGB555.
+    uint16_t bytesA = DrawLinePlane<A>(lineA, nullptr); // nullptr because plane A can't decode RGB555.
     const uint16_t bytesB = DrawLinePlane<B>(lineB, lineA);
+    if(m_codingMethod[B] == ImageCodingMethod::RGB555)
+        bytesA = bytesB;
 
     DrawLineBackdrop();
 
@@ -202,17 +204,24 @@ void RendererSoftware::OverlayMix() noexcept
 
         if constexpr(MIX)
         {
-            if(fp.a == 0) // When mixing transparent pixels are black (V.5.9.1).
+            if(fp.a == 0 && bp.a == 0) // Front and back plane transparent: only show background.
             {
-                fp = BLACK_PIXEL;
+                *screen++ = backdrop;
             }
-
-            if(bp.a == 0)
+            else
             {
-                bp = BLACK_PIXEL;
-            }
+                if(fp.a == 0) // When mixing transparent pixels are black (V.5.9.1).
+                {
+                    fp = BLACK_PIXEL;
+                }
+
+                if(bp.a == 0)
+                {
+                    bp = BLACK_PIXEL;
+                }
 
-            mix(*screen++, fp, bp);
+                mix(*screen++, fp, bp);
+            }
         }
         else // Overlay.
         {
diff --git a/src/CDI/Video/VideoDecodersSIMD.cpp b/src/CDI/Video/VideoDecodersSIMD.cpp
diff --git a/src/CDI/cores/MCD212/Registers.cpp b/src/CDI/cores/MCD212/Registers.cpp
