fix rebase conflicts

Author: EmilioLaiso

examples/test.rs

@@ -1,4 +1,4 @@
-use image::{RgbImage, RgbaImage};
+use image::{GrayAlphaImage, GrayImage, RgbImage, RgbaImage};
 use ispc_downsampler::{downsample_with_custom_scale, Format, Image};
 use stb_image::image::{load, LoadResult};
 use std::path::Path;
@@ -11,10 +11,18 @@ fn main() {
         LoadResult::ImageU8(img) => {
             assert!(!img.data.is_empty());
 
-            let src_fmt = if img.data.len() / (img.width * img.height) == 4 {
+            let num_channels = img.data.len() / (img.width * img.height);
+
+            let src_fmt = if num_channels == 4 {
                 Format::Rgba8
-            } else {
+            } else if num_channels == 3 {
                 Format::Rgb8
+            } else if num_channels == 2 {
+                Format::Rg8
+            } else if num_channels == 1 {
+                Format::R8
+            } else {
+                panic!("We expect a number of channels in the [1, 4] range");
             };
 
             println!("Loaded image!");
@@ -32,6 +40,22 @@ fn main() {
 
             std::fs::create_dir_all("example_outputs").unwrap();
             match src_fmt {
+                Format::R8 => {
+                    let save_image =
+                        GrayImage::from_vec(target_width, target_height, downsampled_pixels)
+                            .unwrap();
+                    save_image
+                        .save("example_outputs/square_test_result.png")
+                        .unwrap()
+                }
+                Format::Rg8 => {
+                    let save_image =
+                        GrayAlphaImage::from_vec(target_width, target_height, downsampled_pixels)
+                            .unwrap();
+                    save_image
+                        .save("example_outputs/square_test_result.png")
+                        .unwrap()
+                }
                 Format::Rgba8 | Format::Srgba8 => {
                     let save_image =
                         RgbaImage::from_vec(target_width, target_height, downsampled_pixels)

src/ispc/kernels/lanczos3.ispc

@@ -90,22 +90,32 @@ struct SampleWeights {
     uniform const WeightCollection* horizontal_weights;
 };
 
-uint8<3> sample_3_channels(const uniform uint8* varying pixel_ptr) {
+uint8<1> sample_1_channel(const uniform uint8* varying pixel_ptr) {
+    const uniform uint8<1>* pixel_ptr1 = (const uniform uint8<1>*)(pixel_ptr);
+    varying uint8<1> dst = {0};
+    dst = *pixel_ptr1;
+    return dst;
+}
+
+void clean_and_write_1_channel(varying float<1> color, uniform uint8* varying pixel_ptr) {
+    pixel_ptr[0] = clamp(color[0], 0.0f, 255.0f);
+}
+
+uint8<2> sample_2_channels(const uniform uint8* varying pixel_ptr) {
     // Memory reinterpretation to read all channels at once rather than one-by-one.
     // While testing, this proved more performant than reading one-by-one.
-    const uniform uint8<3>* pixel_ptr3 = (const uniform uint8<3>*)(pixel_ptr);
-    varying uint8<3> dst = {0, 0, 0};
-    dst = *pixel_ptr3;
+    const uniform uint8<2>* pixel_ptr2 = (const uniform uint8<2>*)(pixel_ptr);
+    varying uint8<2> dst = {0, 0};
+    dst = *pixel_ptr2;
     return dst;
 }
 
-void clean_and_write_3_channels(varying float<3> color, uniform uint8* varying pixel_ptr) {
+void clean_and_write_2_channels(varying float<2> color, uniform uint8* varying pixel_ptr) {
     // The final color is a sum of numbers that are multiplied by the weights of their respective pixels.
     // Because of their numbers, floating point precision leads to the final color being potentially outside of the 0-255 range by a slight margin.
     // This would cause an underflow/overflow, which we avoid with the clamps.
     pixel_ptr[0] = clamp(color[0], 0.0f, 255.0f);
     pixel_ptr[1] = clamp(color[1], 0.0f, 255.0f);
-    pixel_ptr[2] = clamp(color[2], 0.0f, 255.0f);
 }
 
 uint8<4> sample_4_channels(const uniform uint8* varying pixel_ptr) {
@@ -136,22 +146,32 @@ void resample_with_cached_weights(uniform uint32 num_channels, uniform uint32 sr
         uint32 num_horizontal_weights = horizontal_weight_collection->weight_counts[x];
         float* horizontal_weights = horizontal_weight_collection->values[x];
 
+        float<1> color1 = {0.0f};
+        float<2> color2 = {0.0f, 0.0f};
         float<3> color3 = {0.0f, 0.0f, 0.0f};
         float<4> color4 = {0.0f, 0.0f, 0.0f, 0.0f};
         for (uint32 i = 0; i < num_horizontal_weights; i++) {
             float weight = horizontal_weights[i];
             uint32 src_x = src_width_start + i;
             uint64 src_read_address = (y * src_width + src_x) * num_channels;
 
-            if (num_channels == 3)
+            if (num_channels == 1)
+                color1 += sample_1_channel(src_data + src_read_address) * weight;
+            else if (num_channels == 2)
+                color2 += sample_2_channels(src_data + src_read_address) * weight;
+            else if (num_channels == 3)
                 color3 += sample_3_channels(src_data + src_read_address) * weight;
             else
                 color4 += sample_4_channels(src_data + src_read_address) * weight;
         }
 
         uint64 scratch_write_address = (y * target_width + x) * num_channels;
 
-        if (num_channels == 3)
+        if (num_channels == 1)
+            clean_and_write_1_channel(color1, scratch_space + scratch_write_address);
+        else if (num_channels == 2)
+            clean_and_write_3_channels(color2, scratch_space + scratch_write_address);
+        else if (num_channels == 3)
             clean_and_write_3_channels(color3, scratch_space + scratch_write_address);
         else
             clean_and_write_4_channels(color4, scratch_space + scratch_write_address);
@@ -173,15 +193,24 @@ void resample_with_cached_weights(uniform uint32 num_channels, uniform uint32 sr
             uniform uint8<3>* varying scratch_pixel_ptr = (uniform uint8<3>* varying)(scratch_space + scratch_read_address);
             uint8<3> scratch_color = *scratch_pixel_ptr;
 
-            if (num_channels == 3)
+            if (num_channels == 1)
+                color1 += sample_1_channel(scratch_space + scratch_read_address) * weight;
+            else if (num_channels == 2)
+                color2 += sample_2_channels(scratch_space + scratch_read_address) * weight;
+            else if (num_channels == 3)
                 color3 += sample_3_channels(scratch_space + scratch_read_address) * weight;
             else
                 color4 += sample_4_channels(scratch_space + scratch_read_address) * weight;
         }
 
         uint64 out_write_address = (y * target_width + x) * num_channels;
         assert(out_write_address < target_height * target_width * num_channels);
-        if (num_channels == 3)
+
+        if (num_channels == 1)
+            clean_and_write_1_channel(color1, out_data + out_write_address);
+        else if (num_channels == 2)
+            clean_and_write_2_channels(color2, out_data + out_write_address);
+        else if (num_channels == 3)
             clean_and_write_3_channels(color3, out_data + out_write_address);
         else
             clean_and_write_4_channels(color4, out_data + out_write_address);