Fix partial pixel counts in kernel for NEON

Author: Gin

SerialPrograms/Source/CommonFramework/Logging/FileWindowLogger.cpp

@@ -241,6 +241,8 @@ FileWindowLoggerWindow::FileWindowLoggerWindow(FileWindowLogger& logger, QWidget
     log("<b>Window Startup...</b>");
     log("Current path: " + QDir::currentPath());
     log("Executable path: " + qApp->applicationDirPath());
+    log(QString::fromStdString("Program setting folder: " + SETTINGS_PATH()));
+    log(QString::fromStdString("Program resources folder: " + RESOURCE_PATH()));
     add_window(*this);
 }
 FileWindowLoggerWindow::~FileWindowLoggerWindow(){

SerialPrograms/Source/Kernels/ImageFilters/RGB32_EuclideanDistance/Kernels_ImageFilter_RGB32_Euclidean_ARM64_NEON.cpp

@@ -9,6 +9,7 @@
 #include "Kernels/Kernels_arm64_NEON.h"
 #include "Kernels/ImageFilters/Kernels_ImageFilter_Basic_Routines.h"
 #include "Kernels_ImageFilter_RGB32_Euclidean.h"
+#include "Kernels/PartialWordAccess/Kernels_PartialWordAccess_arm64_NEON.h"
 
 namespace PokemonAutomation{
 namespace Kernels{
@@ -36,7 +37,12 @@ class ImageFilter_RgbEuclidean_arm64_NEON{
         return sum_u64[0] + sum_u64[1];
     }
 
-    PA_FORCE_INLINE void process_full(uint32_t* out, const uint32_t* in){
+    // 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 in or out of the range to have the new color m_replacement_color_u32.
+    // The resulting pixels are saved in out[4]
+    PA_FORCE_INLINE void process_full(uint32_t out[4], const uint32_t in[4], const uint32x4_t* cmp_mask_u32 = nullptr){
         uint32x4_t in_u32 = vld1q_u32(in);
         // subtract the expected values
         uint32x4_t in_dif_u32 = vreinterpretq_u32_u8(vabdq_u8(vreinterpretq_u8_u32(in_u32), m_expected_color_rgb_u8));
@@ -58,6 +64,9 @@ class ImageFilter_RgbEuclidean_arm64_NEON{
 
         // cmp_u32: if each pixel is within the range, its uint32_t in `cmp_u32` is all 1 bits, otherwise, all 0 bits
         uint32x4_t cmp_u32 = vcleq_u32(sum_sqr_u32, m_distance_squared_u32);
+        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);
@@ -71,10 +80,12 @@ class ImageFilter_RgbEuclidean_arm64_NEON{
         }
         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);
+        process_full(buffer_out, buffer_in, &cmp_mask_u32);
         memcpy(out, buffer_out, sizeof(uint32_t) * left);
     }
 

SerialPrograms/Source/Kernels/ImageFilters/RGB32_Range/Kernels_ImageFilter_RGB32_Range_ARM64_NEON.cpp

@@ -10,6 +10,9 @@
 #include "Kernels/ImageFilters/Kernels_ImageFilter_Basic_Routines.h"
 #include "Kernels_ImageFilter_RGB32_Range_Routines.h"
 #include "Kernels_ImageFilter_RGB32_Range.h"
+#include "Kernels/PartialWordAccess/Kernels_PartialWordAccess_arm64_NEON.h"
+
+
 
 namespace PokemonAutomation{
 namespace Kernels{
@@ -37,11 +40,17 @@ class ImageFilterRunner_Rgb32Range_ARM64_NEON{
     {}
 
     PA_FORCE_INLINE size_t count() const{
+        // long pairwise add
         uint64x2_t sum_u64 = vpaddlq_u32(m_count_u32);
         return sum_u64[0] + sum_u64[1];
     }
 
-    PA_FORCE_INLINE void process_full(uint32_t* out, const uint32_t* in){
+    // 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 in or out of the range to have the new color m_replacement_color_u32.
+    // The resulting pixels are saved in out[4]
+    PA_FORCE_INLINE void process_full(uint32_t out[4], const uint32_t in[4], const uint32x4_t* cmp_mask_u32 = nullptr){
         uint8x16_t in_u8 = vreinterpretq_u8_u32(vld1q_u32(in));
 
         // Check if mins > pixel per color channel
@@ -50,9 +59,13 @@ class ImageFilterRunner_Rgb32Range_ARM64_NEON{
         uint8x16_t cmp1 = vcgtq_u8(in_u8, m_maxs_u8);
         // cmp: if mins > pixel or pixel > maxs per color channel
         uint8x16_t cmp_u8 = vorrq_u8(cmp0, cmp1);
+        // vceqq_u32: compare bitwise equal
         // cmp_u32: if each pixel is within the range
         // If a pixel is within [mins, maxs], its uint32_t in `cmp_u32` is all 1 bits, otherwise, all 0 bits
-        uint32x4_t cmp_u32 = vceqq_u32(vreinterpretq_u32_u8(cmp_u8), m_zeros_u8);
+        uint32x4_t cmp_u32 = vceqq_u32(vreinterpretq_u32_u8(cmp_u8), vreinterpretq_u32_u8(m_zeros_u8));
+        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);
@@ -66,10 +79,12 @@ class ImageFilterRunner_Rgb32Range_ARM64_NEON{
         }
         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);
+        process_full(buffer_out, buffer_in, &cmp_mask_u32);
         memcpy(out, buffer_out, sizeof(uint32_t) * left);
     }
 
@@ -135,7 +150,12 @@ class ToBlackWhite_RgbRange_arm64_NEON{
         return sum_u64[0] + sum_u64[1];
     }
 
-    PA_FORCE_INLINE void process_full(uint32_t* out, const uint32_t* in){
+    // 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[4], const uint32_t in[4], const uint32x4_t* cmp_mask_u32 = nullptr){
         uint8x16_t in_u8 = vreinterpretq_u8_u32(vld1q_u32(in));
 
         // Check if mins > pixel per color channel
@@ -144,9 +164,13 @@ class ToBlackWhite_RgbRange_arm64_NEON{
         uint8x16_t cmp1 = vcgtq_u8(in_u8, m_maxs_u8);
         // cmp: if mins > pixel or pixel > maxs per color channel
         uint8x16_t cmp_u8 = vorrq_u8(cmp0, cmp1);
+        // vceqq_u32: compare bitwise equal
         // cmp_u32: if each pixel is within the range
         // If a pixel is within [mins, maxs], its uint32_t in `cmp_u32` is all 1 bits, otherwise, all 0 bits
-        uint32x4_t cmp_u32 = vceqq_u32(vreinterpretq_u32_u8(cmp_u8), m_zeros_u8);
+        uint32x4_t cmp_u32 = vceqq_u32(vreinterpretq_u32_u8(cmp_u8), vreinterpretq_u32_u8(m_zeros_u8));
+        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);
@@ -157,10 +181,12 @@ class ToBlackWhite_RgbRange_arm64_NEON{
 
         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);
+        process_full(buffer_out, buffer_in, &cmp_mask_u32);
         memcpy(out, buffer_out, sizeof(uint32_t) * left);
     }
 

SerialPrograms/Source/Kernels/PartialWordAccess/Kernels_PartialWordAccess_arm64_NEON.h

@@ -22,6 +22,14 @@ namespace Kernels{
 // 
 class PartialWordAccess_arm64_NEON{
 public:
+    // create a mask with first `bytes` low bytes are all 1s
+    // If `bytes` is 3, then the returned vector is from low bytes to high bytes: [0xFF, 0xFF, 0xFF, 0, 0, 0, ..., 0]
+    PA_FORCE_INLINE static uint8x16_t create_front_mask(size_t bytes) {
+        PA_ALIGN_STRUCT(16) uint8_t bytes_values[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+        const uint8x16_t seq_u8x16 = vld1q_u8(bytes_values);
+        return vcgtq_u8(vdupq_n_u8((uint8_t)bytes), seq_u8x16);
+    }
+
     // How many bytes of data to load. Allow at most 16 bytes.
     PA_FORCE_INLINE PartialWordAccess_arm64_NEON(size_t bytes)
         : m_shift(16 - bytes)

SerialPrograms/Source/Tests/Kernels_Tests.cpp

@@ -358,8 +358,12 @@ int test_kernels_ToBlackWhiteRGB32Range(const ImageViewRGB32& image){
     cout << "Testing to_black_white_rgb32_range(), image size " << width << " x " << height << endl;
 
     Color min_color(0, 0, 0);
+    // Color min_color(0);
+
     Color max_color(63, 63, 63);
+    // Color max_color(255, 255, 255);
     // Color max_color(238, 24, 42);
+    cout << "min color: " << min_color.to_string() << " max color: " << max_color.to_string() << endl;
 
     const uint32_t mins = uint32_t(min_color);
     const uint32_t maxs = uint32_t(max_color);