Get rid of delegates for combiners

Add a new function _pixman_implementation_lookup_combiner() that will
find a usable combiner given an operator and information about whether
the combiner should apply component alpha and whether it should be 64
bit.

In pixman-general.c use this function to look up a combiner up front
instead of walking the delegate chain for every scanline.

diff --git a/pixman/pixman-general.c b/pixman/pixman-general.c
index 2ccdfcd..27fa3ab 100644 (file)
--- a/pixman/pixman-general.c
+++ b/pixman/pixman-general.c
@@ -171,20 +171,8 @@ general_composite_rect  (pixman_implementation_t *imp,
        imp->toplevel, &dest_iter, dest_image, dest_x, dest_y, width, height,
        dest_buffer, narrow | op_flags[op].dst);
 
-    if (narrow)
-    {
-       if (component_alpha)
-           compose = _pixman_implementation_combine_32_ca;
-       else
-           compose = _pixman_implementation_combine_32;
-    }
-    else
-    {
-       if (component_alpha)
-           compose = (pixman_combine_32_func_t)_pixman_implementation_combine_64_ca;
-       else
-           compose = (pixman_combine_32_func_t)_pixman_implementation_combine_64;
-    }
+    compose = _pixman_implementation_lookup_combiner (
+       imp->toplevel, op, component_alpha, narrow);
 
     if (!compose)
        return;

diff --git a/pixman/pixman-implementation.c b/pixman/pixman-implementation.c
index 2b7b19d..b0a2959 100644 (file)
--- a/pixman/pixman-implementation.c
+++ b/pixman/pixman-implementation.c
@@ -27,54 +27,6 @@
 #include <stdlib.h>
 #include "pixman-private.h"
 
-static void
-delegate_combine_32 (pixman_implementation_t * imp,
-                     pixman_op_t               op,
-                     uint32_t *                dest,
-                     const uint32_t *          src,
-                     const uint32_t *          mask,
-                     int                       width)
-{
-    _pixman_implementation_combine_32 (imp->delegate,
-                                       op, dest, src, mask, width);
-}
-
-static void
-delegate_combine_64 (pixman_implementation_t * imp,
-                     pixman_op_t               op,
-                     uint64_t *                dest,
-                     const uint64_t *          src,
-                     const uint64_t *          mask,
-                     int                       width)
-{
-    _pixman_implementation_combine_64 (imp->delegate,
-                                       op, dest, src, mask, width);
-}
-
-static void
-delegate_combine_32_ca (pixman_implementation_t * imp,
-                        pixman_op_t               op,
-                        uint32_t *                dest,
-                        const uint32_t *          src,
-                        const uint32_t *          mask,
-                        int                       width)
-{
-    _pixman_implementation_combine_32_ca (imp->delegate,
-                                          op, dest, src, mask, width);
-}
-
-static void
-delegate_combine_64_ca (pixman_implementation_t * imp,
-                        pixman_op_t               op,
-                        uint64_t *                dest,
-                        const uint64_t *          src,
-                        const uint64_t *          mask,
-                        int                       width)
-{
-    _pixman_implementation_combine_64_ca (imp->delegate,
-                                          op, dest, src, mask, width);
-}
-
 static pixman_bool_t
 delegate_blt (pixman_implementation_t * imp,
               uint32_t *                src_bits,
@@ -150,61 +102,44 @@ _pixman_implementation_create (pixman_implementation_t *delegate,
     imp->src_iter_init = delegate_src_iter_init;
     imp->dest_iter_init = delegate_dest_iter_init;
 
+    imp->fast_paths = fast_paths;
+
     for (i = 0; i < PIXMAN_N_OPERATORS; ++i)
     {
-       imp->combine_32[i] = delegate_combine_32;
-       imp->combine_64[i] = delegate_combine_64;
-       imp->combine_32_ca[i] = delegate_combine_32_ca;
-       imp->combine_64_ca[i] = delegate_combine_64_ca;
+       imp->combine_32[i] = NULL;
+       imp->combine_64[i] = NULL;
+       imp->combine_32_ca[i] = NULL;
+       imp->combine_64_ca[i] = NULL;
     }
 
-    imp->fast_paths = fast_paths;
-
     return imp;
 }
 
-void
-_pixman_implementation_combine_32 (pixman_implementation_t * imp,
-                                   pixman_op_t               op,
-                                   uint32_t *                dest,
-                                   const uint32_t *          src,
-                                   const uint32_t *          mask,
-                                   int                       width)
+pixman_combine_32_func_t
+_pixman_implementation_lookup_combiner (pixman_implementation_t *imp,
+                                       pixman_op_t              op,
+                                       pixman_bool_t            component_alpha,
+                                       pixman_bool_t            narrow)
 {
-    (*imp->combine_32[op]) (imp, op, dest, src, mask, width);
-}
+    pixman_combine_32_func_t f;
 
-void
-_pixman_implementation_combine_64 (pixman_implementation_t * imp,
-                                   pixman_op_t               op,
-                                   uint64_t *                dest,
-                                   const uint64_t *          src,
-                                   const uint64_t *          mask,
-                                   int                       width)
-{
-    (*imp->combine_64[op]) (imp, op, dest, src, mask, width);
-}
+    do
+    {
+       pixman_combine_32_func_t (*combiners[]) =
+       {
+           (pixman_combine_32_func_t *)imp->combine_64,
+           (pixman_combine_32_func_t *)imp->combine_64_ca,
+           imp->combine_32,
+           imp->combine_32_ca,
+       };
 
-void
-_pixman_implementation_combine_32_ca (pixman_implementation_t * imp,
-                                      pixman_op_t               op,
-                                      uint32_t *                dest,
-                                      const uint32_t *          src,
-                                      const uint32_t *          mask,
-                                      int                       width)
-{
-    (*imp->combine_32_ca[op]) (imp, op, dest, src, mask, width);
-}
+       f = combiners[component_alpha | (narrow << 1)][op];
 
-void
-_pixman_implementation_combine_64_ca (pixman_implementation_t * imp,
-                                      pixman_op_t               op,
-                                      uint64_t *                dest,
-                                      const uint64_t *          src,
-                                      const uint64_t *          mask,
-                                      int                       width)
-{
-    (*imp->combine_64_ca[op]) (imp, op, dest, src, mask, width);
+       imp = imp->delegate;
+    }
+    while (!f);
+
+    return f;
 }
 
 pixman_bool_t

diff --git a/pixman/pixman-private.h b/pixman/pixman-private.h
index 1443bfb..8560385 100644 (file)
--- a/pixman/pixman-private.h
+++ b/pixman/pixman-private.h
@@ -475,34 +475,11 @@ pixman_implementation_t *
 _pixman_implementation_create (pixman_implementation_t *delegate,
                               const pixman_fast_path_t *fast_paths);
 
-void
-_pixman_implementation_combine_32 (pixman_implementation_t *imp,
-                                   pixman_op_t              op,
-                                   uint32_t *               dest,
-                                   const uint32_t *         src,
-                                   const uint32_t *         mask,
-                                   int                      width);
-void
-_pixman_implementation_combine_64 (pixman_implementation_t *imp,
-                                   pixman_op_t              op,
-                                   uint64_t *               dest,
-                                   const uint64_t *         src,
-                                   const uint64_t *         mask,
-                                   int                      width);
-void
-_pixman_implementation_combine_32_ca (pixman_implementation_t *imp,
-                                      pixman_op_t              op,
-                                      uint32_t *               dest,
-                                      const uint32_t *         src,
-                                      const uint32_t *         mask,
-                                      int                      width);
-void
-_pixman_implementation_combine_64_ca (pixman_implementation_t *imp,
-                                      pixman_op_t              op,
-                                      uint64_t *               dest,
-                                      const uint64_t *         src,
-                                      const uint64_t *         mask,
-                                      int                      width);
+pixman_combine_32_func_t
+_pixman_implementation_lookup_combiner (pixman_implementation_t *imp,
+                                       pixman_op_t              op,
+                                       pixman_bool_t            component_alpha,
+                                       pixman_bool_t            wide);
 
 pixman_bool_t
 _pixman_implementation_blt (pixman_implementation_t *imp,