Refactor out ToBlackWhite routines.

Author: Mysticial

Common/Cpp/PixelRGB32.h

@@ -0,0 +1,51 @@
+/*  Pixel: RGB32
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  Perform a filter over an image and replace pixels that match the filter.
+ *
+ */
+
+#ifndef PokemonAutomation_Pixel_RGB32_H
+#define PokemonAutomation_Pixel_RGB32_H
+
+#include <stdint.h>
+
+namespace PokemonAutomation{
+
+
+
+
+
+union PixelRGB32{
+    struct{
+        uint8_t blue;
+        uint8_t green;
+        uint8_t red;
+        uint8_t alpha;
+    } parts;
+    uint32_t u32;
+
+    PixelRGB32(uint32_t value)
+        : u32(value)
+    {}
+    PixelRGB32(uint8_t red, uint8_t green, uint8_t blue){
+        parts.alpha = 0xff;
+        parts.red = red;
+        parts.green = green;
+        parts.blue = blue;
+    }
+    PixelRGB32(uint8_t alpha, uint8_t red, uint8_t green, uint8_t blue){
+        parts.alpha = alpha;
+        parts.red = red;
+        parts.green = green;
+        parts.blue = blue;
+    }
+};
+
+
+
+
+
+}
+#endif

SerialPrograms/CMakeLists.txt

@@ -762,6 +762,7 @@ file(GLOB MAIN_SOURCES
     Source/Kernels/ImageFilters/Kernels_ImageFilter_Basic.h
     Source/Kernels/ImageFilters/Kernels_ImageFilter_Basic_Default.cpp
     Source/Kernels/ImageFilters/Kernels_ImageFilter_Basic_Routines.h
+    Source/Kernels/ImageFilters/Kernels_ImageFilter_Basic_Routines_ARM64_NEON.h
     Source/Kernels/ImageFilters/Kernels_ImageFilter_Basic_Routines_Default.h
     Source/Kernels/ImageFilters/Kernels_ImageFilter_Basic_Routines_x64_AVX2.h
     Source/Kernels/ImageFilters/Kernels_ImageFilter_Basic_Routines_x64_AVX512.h

SerialPrograms/SerialPrograms.pro

@@ -1587,6 +1587,7 @@ HEADERS += \
     Source/Kernels/BinaryMatrix/Kernels_SparseBinaryMatrixCore.h \
     Source/Kernels/BinaryMatrix/Kernels_SparseBinaryMatrixCore.tpp \
     Source/Kernels/ImageFilters/Kernels_ImageFilter_Basic.h \
+    Source/Kernels/ImageFilters/Kernels_ImageFilter_Basic_Routines_ARM64_NEON.h \
     Source/Kernels/ImageFilters/Kernels_ImageFilter_Basic_Routines_Default.h \
     Source/Kernels/ImageFilters/Kernels_ImageFilter_Basic_Routines_x64_AVX2.h \
     Source/Kernels/ImageFilters/Kernels_ImageFilter_Basic_Routines_x64_AVX512.h \

SerialPrograms/Source/Kernels/ImageFilters/Kernels_ImageFilter_Basic_Routines_ARM64_NEON.h

@@ -0,0 +1,82 @@
+/*  Image Filters Basic Routines
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include <stdint.h>
+#include "Common/Compiler.h"
+#include "Kernels/PartialWordAccess/Kernels_PartialWordAccess_arm64_NEON.h"
+#include "Kernels/Kernels_arm64_NEON.h"
+
+namespace PokemonAutomation{
+namespace Kernels{
+
+
+
+template <typename PixelTester>
+class ToBlackWhite_Rgb32_ARM64_NEON{
+public:
+    static const size_t VECTOR_SIZE = 4;
+    using Mask = size_t;
+
+public:
+    ToBlackWhite_Rgb32_ARM64_NEON(
+        const PixelTester& tester,
+        bool in_range_black
+    )
+        : m_tester(tester)
+        , m_in_range_color_u32(vdupq_n_u32(in_range_black ? 0xFF000000 : 0xFFFFFFFF))
+        , m_out_of_range_color_u32(vdupq_n_u32(in_range_black ? 0xFFFFFFFF : 0xFF000000))
+        , m_count_u32(vdupq_n_u32(0))
+    {}
+
+    PA_FORCE_INLINE size_t count() const{
+        uint64x2_t sum_u64 = vpaddlq_u32(m_count_u32);
+        return sum_u64[0] + sum_u64[1];
+    }
+
+    // Given 4 pixels from in[4], apply color range comparison and count the pixels that are in range.
+    // The counts are stored in m_count_u32.
+    // If a per-pixel mask, cmp_mask_u32 is not nullptr, it only counts the pixels covered by the mask.
+    // It also changes pixels into black or white depending on whether they are in range.
+    // The resulting pixels are saved in out[4]
+    PA_FORCE_INLINE void process_full(uint32_t* out, const uint32_t* in){
+        uint32x4_t pixel = vld1q_u32(in);
+        uint32x4_t cmp_u32 = process_word(pixel);
+        if (cmp_mask_u32) {
+            cmp_u32 = vandq_u32(cmp_u32, *cmp_mask_u32);
+        }
+        // Increase count for each pixel in range. Each uint32 lane is counted separately.
+        // We achieve +=1 by substracting 0xFFFFFFFF
+        m_count_u32 = vsubq_u32(m_count_u32, cmp_u32);
+        // select replacement color or in_u8 based on cmp_u32:
+        uint32x4_t out_u32;
+        // vbslq_u32(a, b, c) for 1 bits in a, choose b; for 0 bits in a, choose c
+        out_u32 = vbslq_u32(cmp_u32, m_in_range_color_u32, m_out_of_range_color_u32);
+
+        vst1q_u32(out, out_u32);
+    }
+
+    // Same as `process_full()` but only process `left` (< 4) pixels
+    PA_FORCE_INLINE void process_partial(uint32_t* out, const uint32_t* in, size_t left){
+        uint32x4_t cmp_mask_u32 = vreinterpretq_u32_u8(PartialWordAccess_arm64_NEON::create_front_mask(left * 4));
+        uint32_t buffer_in[4], buffer_out[4];
+        memcpy(buffer_in, in, sizeof(uint32_t) * left);
+        process_full(buffer_out, buffer_in, &cmp_mask_u32);
+        memcpy(out, buffer_out, sizeof(uint32_t) * left);
+    }
+
+private:
+    const PixelTester m_tester;
+    uint32x4_t m_in_range_color_u32;
+    uint32x4_t m_out_of_range_color_u32;
+    uint32x4_t m_count_u32;
+};
+
+
+
+
+
+}
+}

SerialPrograms/Source/Kernels/ImageFilters/Kernels_ImageFilter_Basic_Routines_Default.h

@@ -0,0 +1,56 @@
+/*  Image Filters Basic Routines
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include <stdint.h>
+#include "Common/Compiler.h"
+
+namespace PokemonAutomation{
+namespace Kernels{
+
+
+
+template <typename PixelTester>
+class ToBlackWhite_Rgb32_Default{
+public:
+    static const size_t VECTOR_SIZE = 1;
+    using Mask = size_t;
+
+public:
+    ToBlackWhite_Rgb32_Default(
+        const PixelTester& tester,
+        bool in_range_black
+    )
+        : m_tester(tester)
+        , m_in_range_black(in_range_black ? 1 : 0)
+        , m_count(0)
+    {}
+
+    PA_FORCE_INLINE size_t count() const{
+        return m_count;
+    }
+
+    PA_FORCE_INLINE void process_full(uint32_t* out, const uint32_t* in){
+        uint32_t pixel = in[0];
+        bool passed = m_tester.test_word(pixel);
+        m_count += passed;
+        passed ^= m_in_range_black;
+        out[0] = passed ? 0xffffffff : 0xff000000;
+    }
+    PA_FORCE_INLINE void process_partial(uint32_t* out, const uint32_t* in, size_t left){
+        process_full(out, in);
+    }
+
+private:
+    const PixelTester m_tester;
+    const bool m_in_range_black;
+    size_t m_count;
+};
+
+
+
+
+}
+}

SerialPrograms/Source/Kernels/ImageFilters/Kernels_ImageFilter_Basic_Routines_x64_AVX2.h

@@ -0,0 +1,75 @@
+/*  Image Filters Basic Routines
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include <stdint.h>
+#include <immintrin.h>
+#include "Common/Compiler.h"
+#include "Kernels/Kernels_x64_AVX2.h"
+#include "Kernels/PartialWordAccess/Kernels_PartialWordAccess_x64_AVX2.h"
+
+namespace PokemonAutomation{
+namespace Kernels{
+
+
+
+
+template <typename PixelTester>
+class ToBlackWhite_Rgb32_x64_AVX2{
+public:
+    static const size_t VECTOR_SIZE = 8;
+    using Mask = PartialWordAccess32_x64_AVX2;
+
+public:
+    ToBlackWhite_Rgb32_x64_AVX2(
+        const PixelTester& tester,
+        bool in_range_black
+    )
+        : m_tester(tester)
+        , m_in_range_black(_mm256_set1_epi32(in_range_black ? -1 : 0))
+        , m_count(_mm256_setzero_si256())
+    {}
+
+    PA_FORCE_INLINE size_t count() const{
+        return reduce_add32_x64_AVX2(m_count);
+    }
+
+    PA_FORCE_INLINE void process_full(uint32_t* out, const uint32_t* in){
+        __m256i pixel = _mm256_loadu_si256((const __m256i*)in);
+        __m256i in_range_pixels = process_word(pixel);
+        m_count = _mm256_sub_epi32(m_count, in_range_pixels);
+        _mm256_storeu_si256((__m256i*)out, pixel);
+    }
+    PA_FORCE_INLINE void process_partial(uint32_t* out, const uint32_t* in, const Mask& mask){
+        __m256i pixel = mask.load_i32(in);
+        __m256i in_range_pixels = process_word(pixel);
+        in_range_pixels = _mm256_and_si256(in_range_pixels, mask.mask());
+        m_count = _mm256_sub_epi32(m_count, in_range_pixels);
+        mask.store(out, pixel);
+    }
+
+private:
+    //  Process the pixel in-place.
+    //  Return a mask indicating which lanes are in range.
+    PA_FORCE_INLINE __m256i process_word(__m256i& pixel) const{
+        __m256i mask = m_tester.test_word(pixel);
+        pixel = _mm256_or_si256(
+            _mm256_xor_si256(mask, m_in_range_black),
+            _mm256_set1_epi32(0xff000000)
+        );
+        return mask;
+    }
+
+private:
+    const PixelTester m_tester;
+    const __m256i m_in_range_black;
+    __m256i m_count;
+};
+
+
+
+
+}
+}

SerialPrograms/Source/Kernels/ImageFilters/Kernels_ImageFilter_Basic_Routines_x64_AVX512.h

@@ -0,0 +1,87 @@
+/*  Image Filters Basic Routines
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include <stdint.h>
+#include <immintrin.h>
+#include "Common/Compiler.h"
+
+namespace PokemonAutomation{
+namespace Kernels{
+
+
+
+struct PartialWordMask{
+    __mmask16 m;
+
+    PA_FORCE_INLINE PartialWordMask(size_t left)
+        : m(((__mmask16)1 << left) - 1)
+    {}
+};
+
+
+
+
+template <typename PixelTester>
+class ToBlackWhite_Rgb32_x64_AVX512{
+public:
+    static const size_t VECTOR_SIZE = 16;
+    using Mask = PartialWordMask;
+
+public:
+    ToBlackWhite_Rgb32_x64_AVX512(
+        const PixelTester& tester,
+        bool in_range_black
+    )
+        : m_tester(tester)
+        , m_in_range_color(_mm512_set1_epi32(in_range_black ? 0xff000000 : 0xffffffff))
+        , m_out_range_color(_mm512_set1_epi32(in_range_black ? 0xffffffff : 0xff000000))
+        , m_count(_mm512_setzero_si512())
+    {}
+
+    PA_FORCE_INLINE size_t count() const{
+        return _mm512_reduce_add_epi32(m_count);
+    }
+
+    PA_FORCE_INLINE void process_full(uint32_t* out, const uint32_t* in){
+        __m512i pixel = _mm512_loadu_si512((const __m512i*)in);
+        __mmask16 in_range_pixels = process_word(pixel);
+        m_count = _mm512_mask_sub_epi32(m_count, in_range_pixels, m_count, _mm512_set1_epi32(-1));
+        _mm512_storeu_si512((__m512i*)out, pixel);
+    }
+    PA_FORCE_INLINE void process_partial(uint32_t* out, const uint32_t* in, const Mask& mask){
+        __m512i pixel = _mm512_maskz_loadu_epi32(mask.m, in);
+        __mmask16 in_range_pixels = process_word(pixel);
+        in_range_pixels &= mask.m;
+        m_count = _mm512_mask_sub_epi32(m_count, in_range_pixels, m_count, _mm512_set1_epi32(-1));
+        _mm512_mask_storeu_epi32(out, mask.m, pixel);
+    }
+
+private:
+    //  Process the pixel in-place.
+    //  Return a mask indicating which lanes are in range.
+    PA_FORCE_INLINE __mmask16 process_word(__m512i& pixel) const{
+        __mmask16 mask = m_tester.test_word(pixel);
+        pixel = _mm512_mask_blend_epi32(
+            mask,
+            m_out_range_color,
+            m_in_range_color
+        );
+        return mask;
+    }
+
+private:
+    const PixelTester m_tester;
+    const __m512i m_in_range_color;
+    const __m512i m_out_range_color;
+    __m512i m_count;
+};
+
+
+
+
+
+}
+}