Add bilinear filtering to tiled image rendering

Author: sammycage

source/plutovg-blend.c

@@ -68,6 +68,18 @@ static inline uint32_t INTERPOLATE_PIXEL_255(uint32_t x, uint32_t a, uint32_t y,
     return x;
 }
 
+static inline uint32_t INTERPOLATE_PIXEL_256(uint32_t x, uint32_t a, uint32_t y, uint32_t b)
+{
+    uint32_t t = (x & 0xff00ff) * a + (y & 0xff00ff) * b;
+    t >>= 8;
+    t &= 0xff00ff;
+
+    x = ((x >> 8) & 0xff00ff) * a + ((y >> 8) & 0xff00ff) * b;
+    x &= 0xff00ff00;
+    x |= t;
+    return x;
+}
+
 static inline uint32_t BYTE_MUL(uint32_t x, uint32_t a)
 {
     uint32_t t = (x & 0xff00ff) * a;
@@ -854,14 +866,23 @@ static void blend_untransformed_tiled_argb(plutovg_surface_t* surface, plutovg_o
     }
 }
 
+static inline uint32_t interpolate_4_pixels(uint32_t tl, uint32_t tr, uint32_t bl, uint32_t br, uint32_t distx, uint32_t disty)
+{
+    uint32_t idistx = 256 - distx;
+    uint32_t idisty = 256 - disty;
+    uint32_t xtop = INTERPOLATE_PIXEL_256(tl, idistx, tr, distx);
+    uint32_t xbot = INTERPOLATE_PIXEL_256(bl, idistx, br, distx);
+    return INTERPOLATE_PIXEL_256(xtop, idisty, xbot, disty);
+}
+
+#define HALF_POINT (1 << 15)
 static void blend_transformed_tiled_argb(plutovg_surface_t* surface, plutovg_operator_t op, const texture_data_t* texture, const plutovg_span_buffer_t* span_buffer)
 {
     composition_function_t func = composition_table[op];
     uint32_t buffer[BUFFER_SIZE];
 
     int image_width = texture->width;
     int image_height = texture->height;
-    const int scanline_offset = texture->stride / 4;
 
     int fdx = (int)(texture->matrix.a * FIXED_SCALE);
     int fdy = (int)(texture->matrix.b * FIXED_SCALE);
@@ -870,35 +891,46 @@ static void blend_transformed_tiled_argb(plutovg_surface_t* surface, plutovg_ope
     const plutovg_span_t* spans = span_buffer->spans.data;
     while(count--) {
         uint32_t* target = (uint32_t*)(surface->data + spans->y * surface->stride) + spans->x;
-        const uint32_t* image_bits = (const uint32_t*)texture->data;
 
         const float cx = spans->x + 0.5f;
         const float cy = spans->y + 0.5f;
 
-        int x = (int)((texture->matrix.c * cy + texture->matrix.a * cx + texture->matrix.e) * FIXED_SCALE);
-        int y = (int)((texture->matrix.d * cy + texture->matrix.b * cx + texture->matrix.f) * FIXED_SCALE);
+        int fx = (int)((texture->matrix.c * cy + texture->matrix.a * cx + texture->matrix.e) * FIXED_SCALE);
+        int fy = (int)((texture->matrix.d * cy + texture->matrix.b * cx + texture->matrix.f) * FIXED_SCALE);
+
+        fx -= HALF_POINT;
+        fy -= HALF_POINT;
 
         const int coverage = (spans->coverage * texture->const_alpha) >> 8;
         int length = spans->len;
         while(length) {
             int l = plutovg_min(length, BUFFER_SIZE);
             const uint32_t* end = buffer + l;
             uint32_t* b = buffer;
-            while(b < end) {
-                int px = x >> 16;
-                int py = y >> 16;
-                px %= image_width;
-                py %= image_height;
-                if(px < 0) px += image_width;
-                if(py < 0) py += image_height;
-                int y_offset = py * scanline_offset;
+            while (b < end) {
+                int x1 = (fx >> 16) % image_width;
+                int y1 = (fy >> 16) % image_height;
 
-                assert(px >= 0 && px < image_width);
-                assert(py >= 0 && py < image_height);
+                if(x1 < 0) x1 += image_width;
+                if(y1 < 0) y1 += image_height;
 
-                *b = image_bits[y_offset + px];
-                x += fdx;
-                y += fdy;
+                int x2 = (x1 + 1) % image_width;
+                int y2 = (y1 + 1) % image_height;
+
+                const uint32_t* s1 = (const uint32_t*)(texture->data + y1 * texture->stride);
+                const uint32_t* s2 = (const uint32_t*)(texture->data + y2 * texture->stride);
+
+                uint32_t tl = s1[x1];
+                uint32_t tr = s1[x2];
+                uint32_t bl = s2[x1];
+                uint32_t br = s2[x2];
+
+                int distx = (fx & 0x0000ffff) >> 8;
+                int disty = (fy & 0x0000ffff) >> 8;
+                *b = interpolate_4_pixels(tl, tr, bl, br, distx, disty);
+
+                fx += fdx;
+                fy += fdy;
                 ++b;
             }