NONE repeat support for fast scaling with nearest filter

Implemented very similar to PAD repeat.

And gcc also seems to be able to completely eliminate the
code responsible for left and right padding pixels for OVER
operation with NONE repeat.

diff --git a/pixman/pixman-fast-path.c b/pixman/pixman-fast-path.c
index 5b10d65..3bf03d5 100644 (file)
--- a/pixman/pixman-fast-path.c
+++ b/pixman/pixman-fast-path.c
@@ -1388,18 +1388,23 @@ fast_composite_src_memcpy (pixman_implementation_t *imp,
 }
 
 FAST_NEAREST (8888_8888_cover, 8888, 8888, uint32_t, uint32_t, SRC, COVER);
+FAST_NEAREST (8888_8888_none, 8888, 8888, uint32_t, uint32_t, SRC, NONE);
 FAST_NEAREST (8888_8888_pad, 8888, 8888, uint32_t, uint32_t, SRC, PAD);
 FAST_NEAREST (8888_8888_normal, 8888, 8888, uint32_t, uint32_t, SRC, NORMAL);
 FAST_NEAREST (8888_8888_cover, 8888, 8888, uint32_t, uint32_t, OVER, COVER);
+FAST_NEAREST (8888_8888_none, 8888, 8888, uint32_t, uint32_t, OVER, NONE);
 FAST_NEAREST (8888_8888_pad, 8888, 8888, uint32_t, uint32_t, OVER, PAD);
 FAST_NEAREST (8888_8888_normal, 8888, 8888, uint32_t, uint32_t, OVER, NORMAL);
 FAST_NEAREST (8888_565_cover, 8888, 0565, uint32_t, uint16_t, SRC, COVER);
+FAST_NEAREST (8888_565_none, 8888, 0565, uint32_t, uint16_t, SRC, NONE);
 FAST_NEAREST (8888_565_pad, 8888, 0565, uint32_t, uint16_t, SRC, PAD);
 FAST_NEAREST (8888_565_normal, 8888, 0565, uint32_t, uint16_t, SRC, NORMAL);
 FAST_NEAREST (565_565_cover, 0565, 0565, uint16_t, uint16_t, SRC, COVER);
+FAST_NEAREST (565_565_none, 0565, 0565, uint16_t, uint16_t, SRC, NONE);
 FAST_NEAREST (565_565_pad, 0565, 0565, uint16_t, uint16_t, SRC, PAD);
 FAST_NEAREST (565_565_normal, 0565, 0565, uint16_t, uint16_t, SRC, NORMAL);
 FAST_NEAREST (8888_565_cover, 8888, 0565, uint32_t, uint16_t, OVER, COVER);
+FAST_NEAREST (8888_565_none, 8888, 0565, uint32_t, uint16_t, OVER, NONE);
 FAST_NEAREST (8888_565_pad, 8888, 0565, uint32_t, uint16_t, OVER, PAD);
 FAST_NEAREST (8888_565_normal, 8888, 0565, uint32_t, uint16_t, OVER, NORMAL);
 

diff --git a/pixman/pixman-fast-path.h b/pixman/pixman-fast-path.h
index 7c14379..a6b5414 100644 (file)
--- a/pixman/pixman-fast-path.h
+++ b/pixman/pixman-fast-path.h
@@ -309,7 +309,8 @@ fast_composite_scaled_nearest_ ## scale_func_name (pixman_implementation_t *imp,
        repeat (PIXMAN_REPEAT_NORMAL, &vy, max_vy);                                             \
     }                                                                                          \
                                                                                                \
-    if (PIXMAN_REPEAT_ ## repeat_mode == PIXMAN_REPEAT_PAD)                                    \
+    if (PIXMAN_REPEAT_ ## repeat_mode == PIXMAN_REPEAT_PAD ||                                  \
+       PIXMAN_REPEAT_ ## repeat_mode == PIXMAN_REPEAT_NONE)                                    \
     {                                                                                          \
        pad_repeat_get_scanline_bounds (src_image->bits.width, vx, unit_x,                      \
                                        &width, &left_pad, &right_pad);                         \
@@ -343,6 +344,28 @@ fast_composite_scaled_nearest_ ## scale_func_name (pixman_implementation_t *imp,
                                right_pad, 0, 0, 0);                                            \
            }                                                                                   \
        }                                                                                       \
+       else if (PIXMAN_REPEAT_ ## repeat_mode == PIXMAN_REPEAT_NONE)                           \
+       {                                                                                       \
+           static src_type_t zero = 0;                                                         \
+           if (y < 0 || y >= src_image->bits.height)                                           \
+           {                                                                                   \
+               scanline_func (dst, &zero, left_pad + width + right_pad, 0, 0, 0);              \
+               continue;                                                                       \
+           }                                                                                   \
+           src = src_first_line + src_stride * y;                                              \
+           if (left_pad > 0)                                                                   \
+           {                                                                                   \
+               scanline_func (dst, &zero, left_pad, 0, 0, 0);                                  \
+           }                                                                                   \
+           if (width > 0)                                                                      \
+           {                                                                                   \
+               scanline_func (dst + left_pad, src, width, vx, unit_x, 0);                      \
+           }                                                                                   \
+           if (right_pad > 0)                                                                  \
+           {                                                                                   \
+               scanline_func (dst + left_pad + width, &zero, right_pad, 0, 0, 0);              \
+           }                                                                                   \
+       }                                                                                       \
        else                                                                                    \
        {                                                                                       \
            src = src_first_line + src_stride * y;                                              \
@@ -390,6 +413,17 @@ fast_composite_scaled_nearest_ ## scale_func_name (pixman_implementation_t *imp,
        fast_composite_scaled_nearest_ ## func ## _pad ## _ ## op,      \
     }
 
+#define SIMPLE_NEAREST_FAST_PATH_NONE(op,s,d,func)                     \
+    {   PIXMAN_OP_ ## op,                                              \
+       PIXMAN_ ## s,                                                   \
+       (SCALED_NEAREST_FLAGS           |                               \
+        FAST_PATH_NONE_REPEAT          |                               \
+        FAST_PATH_X_UNIT_POSITIVE),                                    \
+       PIXMAN_null, 0,                                                 \
+       PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS,                         \
+       fast_composite_scaled_nearest_ ## func ## _none ## _ ## op,     \
+    }
+
 #define SIMPLE_NEAREST_FAST_PATH_COVER(op,s,d,func)                    \
     {   PIXMAN_OP_ ## op,                                              \
        PIXMAN_ ## s,                                                   \
@@ -402,6 +436,7 @@ fast_composite_scaled_nearest_ ## scale_func_name (pixman_implementation_t *imp,
 /* Prefer the use of 'cover' variant, because it is faster */
 #define SIMPLE_NEAREST_FAST_PATH(op,s,d,func)                          \
     SIMPLE_NEAREST_FAST_PATH_COVER (op,s,d,func),                      \
+    SIMPLE_NEAREST_FAST_PATH_NONE (op,s,d,func),                       \
     SIMPLE_NEAREST_FAST_PATH_PAD (op,s,d,func),                                \
     SIMPLE_NEAREST_FAST_PATH_NORMAL (op,s,d,func)