New SIMD algorithm using casts for mixing (not faster than shifts and masks)

Author: Stovent

src/CDI/Video/RendererSIMD.cpp

@@ -194,24 +194,111 @@ void RendererSIMD::OverlayMix() noexcept
     }
 
     if constexpr(MIX) // Mixing.
-        ApplyICFMixSIMD<PLANE_ORDER>();
+        ApplyICFMixSIMDShift<PLANE_ORDER>();
+        // ApplyICFMixSIMDCast<PLANE_ORDER>();
     else // Overlay.
         ApplyICFOverlaySIMD<PLANE_ORDER>();
 }
 
 using PixelSIMDSigned = stdx::native_simd<int32_t>;
-// using PixelSIMDSignedMask = stdx::native_simd_mask<int32_t>;
+using SIMDU8 = stdx::native_simd<uint8_t>;
+using SIMDS16 = stdx::native_simd<int16_t>;
+using FixedS16 = stdx::fixed_size_simd<int16_t, SIMDS16::size() * sizeof(SIMDS16::value_type)>;
 
 static const PixelSIMDSigned SIXTEEN{16};
-static const PixelSIMDSigned ZERO{0};
-static const PixelSIMDSigned MAX{255};
+static const FixedS16 SIXTEENN{16};
+static const PixelSIMDSigned U8_MIN{0};
+static const FixedS16 U8_MINN{0};
+static const PixelSIMDSigned U8_MAX{255};
+static const FixedS16 U8_MAXX{255};
 static const PixelSIMDSigned ALPHA_MASK{-16777216}; // 0xFF'00'00'00
+static const PixelSIMD ALPHA_MASKK{0xFF'00'00'00}; // 0xFF'00'00'00
 
-/** \brief Applies ICF and mixes using SIMD.
- * \param icfs The front ICF in low 16 bits and the back ICF in high 16 bits
+/** \brief Applies ICF and mixes using SIMD (algorithm that casts the registers to access RGB components).
+ * \tparam PLANE_ORDER true when plane B in front of plane A, false for A in front of B.
  */
 template<bool PLANE_ORDER>
-void RendererSIMD::ApplyICFMixSIMD() noexcept
+void RendererSIMD::ApplyICFMixSIMDCast() noexcept
+{
+    Pixel* screen = m_screenARGB.GetLinePointer(m_lineNumber);
+    const Pixel* planeFront;
+    const Pixel* planeBack;
+    const uint8_t* icfFront;
+    const uint8_t* icfBack;
+    if constexpr(PLANE_ORDER)
+    {
+        planeFront = m_planeLine[B].data();
+        planeBack = m_planeLine[A].data();
+        icfFront = m_icfLine[B].data();
+        icfBack = m_icfLine[A].data();
+    }
+    else
+    {
+        planeFront = m_planeLine[A].data();
+        planeBack = m_planeLine[B].data();
+        icfFront = m_icfLine[A].data();
+        icfBack = m_icfLine[B].data();
+    }
+
+    for(uint16_t i = 0; i < m_plane[A].m_width;
+        i += SIMD_SIZE, planeFront += SIMD_SIZE, planeBack += SIMD_SIZE, icfFront += SIMD_SIZE, icfBack += SIMD_SIZE, screen += SIMD_SIZE) // TODO: width[B].
+    {
+        PixelSIMD icfF{icfFront, stdx::element_aligned};
+        PixelSIMD icfB{icfBack, stdx::element_aligned};
+
+        PixelSIMD planeF{planeFront, stdx::element_aligned};
+        PixelSIMD planeB{planeBack, stdx::element_aligned};
+
+        // transparent areas of an image simply give no contribution to the final display
+        // - that is they are equivalent to black areas..
+        const PixelSIMD::mask_type maskF = (planeF & ALPHA_MASKK) == 0;
+        const PixelSIMD::mask_type maskB = (planeB & ALPHA_MASKK) == 0;
+        stdx::where(maskF, planeF) = 0x00'10'10'10;
+        stdx::where(maskB, planeB) = 0x00'10'10'10;
+        stdx::where(maskF, icfF) = 63;
+        stdx::where(maskB, icfB) = 63;
+
+        // extend ICF to whole register.
+        icfF |= (icfF << 16) | (icfF << 8);
+        icfB |= (icfB << 16) | (icfB << 8);
+
+        SIMDU8 rgbF8 = std::bit_cast<SIMDU8>(planeF);
+        SIMDU8 rgbB8 = std::bit_cast<SIMDU8>(planeB);
+        SIMDU8 icfF8 = std::bit_cast<SIMDU8>(icfF);
+        SIMDU8 icfB8 = std::bit_cast<SIMDU8>(icfB);
+
+        FixedS16 rgbF16 = stdx::static_simd_cast<int16_t>(rgbF8);
+        FixedS16 rgbB16 = stdx::static_simd_cast<int16_t>(rgbB8);
+        FixedS16 icfF16 = stdx::static_simd_cast<int16_t>(icfF8);
+        FixedS16 icfB16 = stdx::static_simd_cast<int16_t>(icfB8);
+
+        rgbF16 -= SIXTEENN;
+        rgbB16 -= SIXTEENN;
+
+        rgbF16 *= icfF16;
+        rgbB16 *= icfB16;
+
+        rgbF16 /= 63;
+        rgbB16 /= 63;
+
+        rgbF16 += SIXTEENN;
+        // rgbB16 += SIXTEENN; Don't add 16 to back plane when applying ICF because the below mixing subtracts it.
+
+        rgbF16 += rgbB16;
+
+        stdx::clamp(rgbF16, U8_MINN, U8_MAXX);
+
+        const PixelSIMD result = std::bit_cast<PixelSIMD>(stdx::static_simd_cast<SIMDU8>(rgbF16));
+
+        result.copy_to(screen, stdx::element_aligned);
+    }
+}
+
+/** \brief Applies ICF and mixes using SIMD (algorithm that shifts and masks RGB components).
+ * \tparam PLANE_ORDER true when plane B in front of plane A, false for A in front of B.
+ */
+template<bool PLANE_ORDER>
+void RendererSIMD::ApplyICFMixSIMDShift() noexcept
 {
     Pixel* screen = m_screenARGB.GetLinePointer(m_lineNumber);
     const Pixel* planeFront;
@@ -242,6 +329,8 @@ void RendererSIMD::ApplyICFMixSIMD() noexcept
         PixelSIMDSigned planeF{planeFront, stdx::element_aligned};
         PixelSIMDSigned planeB{planeBack, stdx::element_aligned};
 
+        // transparent areas of an image simply give no contribution to the final display
+        // - that is they are equivalent to black areas..
         const PixelSIMDSigned::mask_type maskF = (planeF & ALPHA_MASK) == 0;
         const PixelSIMDSigned::mask_type maskB = (planeB & ALPHA_MASK) == 0;
         stdx::where(maskF, planeF) = 0x00'10'10'10;
@@ -292,23 +381,28 @@ void RendererSIMD::ApplyICFMixSIMD() noexcept
         rfp += SIXTEEN;
         gfp += SIXTEEN;
         bfp += SIXTEEN;
-
         // Don't add 16 to back plane when applying ICF because the below mixing subtracts it.
+
         rfp += rbp;
         gfp += gbp;
         bfp += bbp;
 
-        stdx::clamp(rfp, ZERO, MAX);
-        stdx::clamp(gfp, ZERO, MAX);
-        stdx::clamp(bfp, ZERO, MAX);
+        stdx::clamp(rfp, U8_MIN, U8_MAX);
+        stdx::clamp(gfp, U8_MIN, U8_MAX);
+        stdx::clamp(bfp, U8_MIN, U8_MAX);
 
         const PixelSIMDSigned result = (rfp << 16) | (gfp << 8) | bfp;
 
         result.copy_to(screen, stdx::element_aligned);
     }
 }
+// template void RendererSIMD::ApplyICFMixSIMDShift<false>() noexcept;
+// template void RendererSIMD::ApplyICFMixSIMDShift<true>() noexcept;
 
 /** \brief Applies ICF and overlays using SIMD.
+ * \tparam PLANE_ORDER true when plane B in front of plane A, false for A in front of B.
+ *
+ * TODO: implement the cast method here too and benchmark it.
  */
 template<bool PLANE_ORDER>
 void RendererSIMD::ApplyICFOverlaySIMD() noexcept

src/CDI/Video/RendererSIMD.hpp

@@ -28,9 +28,9 @@ class RendererSIMD final : public Renderer
     PlaneSIMD m_cursorPlaneARGB{PlaneSIMD::CURSOR_WIDTH, PlaneSIMD::CURSOR_HEIGHT, PlaneSIMD::CURSOR_ARGB_SIZE};
 
     std::array<std::array<uint8_t, SIMD_LINE_WIDTH>, 2> m_icfLine{};
-    std::array<uint8_t, 2> m_currentICF{};
+    // std::array<uint8_t, 2> m_currentICF{};
     // std::array<std::array<uint8_t, SIMD_LINE_WIDTH>, 2> m_matteFlagLine{};
-    uint32_t m_currentMatteCommand{0};
+    // uint32_t m_currentMatteCommand{0};
 
     RendererSIMD() {}
     virtual ~RendererSIMD() noexcept {}
@@ -44,7 +44,8 @@ class RendererSIMD final : public Renderer
     void DrawCursor() noexcept;
 
     template<bool MIX, bool PLANE_ORDER> void OverlayMix() noexcept;
-    template<bool PLANE_ORDER> void ApplyICFMixSIMD() noexcept;
+    template<bool PLANE_ORDER> void ApplyICFMixSIMDCast() noexcept;
+    template<bool PLANE_ORDER> void ApplyICFMixSIMDShift() noexcept;
     template<bool PLANE_ORDER> void ApplyICFOverlaySIMD() noexcept;
 
     void ResetMatteSIMD() noexcept;