pixman: Changes to 'debian-experimental'
ChangeLog | 864 +++++++++++++++++++++++++++++
Makefile.am | 7
configure.ac | 98 +--
debian/changelog | 37 +
debian/control | 7
debian/libpixman-1-0-udeb.install | 2
debian/libpixman-1-0.install | 2
debian/libpixman-1-dev.install | 6
debian/rules | 10
demos/alpha-test.c | 4
demos/gradient-test.c | 4
demos/tri-test.c | 2
pixman/Makefile.am | 2
pixman/Makefile.win32 | 7
pixman/pixman-access.c | 97 +++
pixman/pixman-arm-common.h | 196 ++++--
pixman/pixman-arm-neon-asm-bilinear.S | 768 ++++++++++++++++++++++++++
pixman/pixman-arm-neon-asm.S | 982 +++++++++++++++++++++++++++++++++-
pixman/pixman-arm-neon-asm.h | 17
pixman/pixman-arm-neon.c | 78 ++
pixman/pixman-arm-simd-asm.S | 66 +-
pixman/pixman-arm-simd.c | 9
pixman/pixman-bits-image.c | 45 -
pixman/pixman-combine.c.template | 7
pixman/pixman-compiler.h | 6
pixman/pixman-conical-gradient.c | 7
pixman/pixman-cpu.c | 2
pixman/pixman-fast-path.c | 436 +++------------
pixman/pixman-fast-path.h | 628 +++++++++++++++++++++
pixman/pixman-general.c | 103 ---
pixman/pixman-image.c | 1
pixman/pixman-implementation.c | 76 --
pixman/pixman-linear-gradient.c | 16
pixman/pixman-mmx.c | 390 +++----------
pixman/pixman-noop.c | 137 ++++
pixman/pixman-private.h | 105 +--
pixman/pixman-radial-gradient.c | 7
pixman/pixman-solid-fill.c | 17
pixman/pixman-sse2.c | 648 ++++++++--------------
pixman/pixman-trap.c | 23
pixman/pixman.c | 76 +-
pixman/pixman.h | 12
test/Makefile.am | 2
test/Makefile.win32 | 73 ++
test/affine-test.c | 6
test/blitters-test.c | 33 -
test/composite-traps-test.c | 8
test/composite.c | 58 +-
test/fetch-test.c | 63 +-
test/lowlevel-blt-bench.c | 84 +-
test/scaling-helpers-test.c | 93 +++
test/scaling-test.c | 6
test/stress-test.c | 41 +
test/trap-crasher.c | 20
test/utils.c | 21
test/utils.h | 5
56 files changed, 4878 insertions(+), 1642 deletions(-)
New commits:
commit 69b4ffdbc990e26ee4af4758a5a87cfbf59b9db5
Author: Cyril Brulebois <kibi@debian.org>
Date: Tue Jul 5 01:37:39 2011 +0200
Upload to experimental.
diff --git a/debian/changelog b/debian/changelog
index ad88f82..34c3392 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,9 +1,9 @@
-pixman (0.23.2-1) UNRELEASED; urgency=low
+pixman (0.23.2-1) experimental; urgency=low
* New upstream release.
* Enable parallel building (by passing --parallel to dh $@).
- -- Cyril Brulebois <kibi@debian.org> Mon, 04 Jul 2011 22:46:51 +0200
+ -- Cyril Brulebois <kibi@debian.org> Tue, 05 Jul 2011 01:37:27 +0200
pixman (0.22.0-1) unstable; urgency=low
commit 351ed700c36c2db531aa10b28b8fe9cfc9adcc56
Author: Cyril Brulebois <kibi@debian.org>
Date: Tue Jul 5 01:36:48 2011 +0200
Enable parallel building (by passing --parallel to dh $@).
diff --git a/debian/changelog b/debian/changelog
index 597c2e6..ad88f82 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,6 +1,7 @@
pixman (0.23.2-1) UNRELEASED; urgency=low
* New upstream release.
+ * Enable parallel building (by passing --parallel to dh $@).
-- Cyril Brulebois <kibi@debian.org> Mon, 04 Jul 2011 22:46:51 +0200
diff --git a/debian/rules b/debian/rules
index f1ac6f7..d7fab98 100755
--- a/debian/rules
+++ b/debian/rules
@@ -29,4 +29,4 @@ override_dh_makeshlibs:
dh_makeshlibs -p$(PACKAGE) --add-udeb $(PACKAGE)-udeb -V"$(PACKAGE) (>= $(SHLIBS))" -- -c4
%:
- dh $@ --with quilt,autoreconf --builddirectory=build/
+ dh $@ --with quilt,autoreconf --builddirectory=build/ --parallel
commit af6efdfd20b11f8ce919c8b0be5c2dbe85cd429d
Author: Cyril Brulebois <kibi@debian.org>
Date: Mon Jul 4 22:47:03 2011 +0200
Bump changelogs.
diff --git a/ChangeLog b/ChangeLog
index 5469ffd..e5bd9e2 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,276 @@
+commit 6c4001a0e1cc0350147638ba941d23e129d00e0d
+Author: Søren Sandmann Pedersen <ssp@redhat.com>
+Date: Mon Jul 4 08:13:19 2011 -0400
+
+ Pre-release version bump to 0.23.2
+
+commit eff7c8efabe2da33edbf0bdc06e101352981286b
+Author: Taekyun Kim <tkq.kim@samsung.com>
+Date: Mon Jun 13 19:53:49 2011 +0900
+
+ Bilinear REPEAT_NORMAL source line extension for too short src_width
+
+ To avoid function call and other calculation overhead, extend source
+ scanline into temporary buffer when source width is too small.
+ Temporary buffer will be repeatedly accessed, so extension cost is
+ very small due to cache effect.
+
+commit 828794d328e7ad1efc860baee8d6e72450b486b9
+Author: Taekyun Kim <tkq.kim@samsung.com>
+Date: Wed Jun 8 17:17:42 2011 +0900
+
+ Enable REPEAT_NORMAL bilinear fast path entries
+
+commit 1161b3f9edb6f5c396438b79f2df3218ea8d194e
+Author: Taekyun Kim <tkq.kim@samsung.com>
+Date: Wed Jun 8 17:14:29 2011 +0900
+
+ ARM: Add REPEAT_NORMAL functions to bilinear BIND macros
+
+ Now bilinear template support REPEAT_NORMAL, so functions for that
+ is added to PIXMAN_ARM_BIND_SCALED_BILINEAR_ macros. Fast path
+ entries are not enabled yet.
+
+commit ebd2f06d96ee91f9f7f13b906ae328862da7dde8
+Author: Taekyun Kim <tkq.kim@samsung.com>
+Date: Wed Jun 8 17:11:24 2011 +0900
+
+ sse2: Declare bilinear src_8888_8888 REPEAT_NORMAL composite function
+
+ Now bilinear template support REPEAT_NORMAL, so declare composite
+ functions using it. Function is just declared not used yet.
+
+commit 7e22b2f7824f844076e1bb1fb26a6ec5e5d029cd
+Author: Taekyun Kim <tkq.kim@samsung.com>
+Date: Wed Jun 8 15:58:01 2011 +0900
+
+ REPEAT_NORMAL support for bilinear fast path template
+
+ The basic idea is to break down normal repeat into a set of
+ non-repeat scanline compositions and stitching them together.
+
+ Bilinear may interpolate last and first pixels of source scanline.
+ In this case, we can use temporary wrap around buffer.
+
+commit 2f025bad436982a2b1c54d7cb49b426ebf198350
+Author: Taekyun Kim <tkq.kim@samsung.com>
+Date: Wed Jun 8 15:37:31 2011 +0900
+
+ Replace boolean arguments with flags for bilinear fast path template
+
+ By replacing boolean arguments with flags, the code can be more
+ readable and flags can be extended to do some more things later.
+
+ Currently following flags are defined.
+
+ FLAG_NONE
+ - No flags are turned on.
+
+ FLAG_HAVE_SOLID_MASK
+ - Template will generate solid mask composite functions.
+
+ FLAG_HAVE_NON_SOLID_MASK
+ - Template will generate bits mask composite functions.
+
+ FLAG_HAVE_SOLID_MASK and FLAG_NON_SOLID_MASK should be mutually
+ exclusive.
+
+commit 4d4d1760e8118aaea06783079a3b87f83deb4907
+Author: Søren Sandmann <ssp@redhat.com>
+Date: Sat Jun 25 10:16:25 2011 -0400
+
+ test: Make fuzzer-find-diff.pl executable
+
+commit ece8d13bf77d050662bb9db9716576dabff37554
+Author: Søren Sandmann <sandmann@cs.au.dk>
+Date: Sun Jun 19 20:29:08 2011 -0400
+
+ ARM: Fix two bugs in neon_composite_over_n_8888_0565_ca().
+
+ The first bug is that a vmull.u8 instruction would store its result in
+ the q1 register, clobbering the d2 register used later on. The second
+ is that a vraddhn instruction would overwrite d25, corrupting the q12
+ register used later.
+
+ Fixing the second bug caused a pipeline bubble where the d18 register
+ would be unavailable for a clock cycle. This is fixed by swapping the
+ instruction with its successor.
+
+commit 5715a394c41b2fd259ce7bf07b859d2a4eb2ec09
+Author: Søren Sandmann Pedersen <ssp@redhat.com>
+Date: Sun Jun 19 19:10:45 2011 -0400
+
+ blitters-test: Make common formats more likely to be tested.
+
+ Move the eight most common formats to the top of the list of image
+ formats and make create_random_image() much more likely to select one
+ of those eight formats.
+
+ This should help catch more bugs in SIMD optimized operations.
+
+commit d815a1c54ae6ea6ccd16dedb7f83db0d2526d637
+Author: Andrea Canciani <ranma42@gmail.com>
+Date: Fri Jun 10 08:56:10 2011 +0200
+
+ Silence autoconf warnings
+
+ Autoconf 2.86 reports:
+
+ warning: AC_LANG_CONFTEST: no AC_LANG_SOURCE call detected in body
+
+ Every code fragment must be wrapped in [AC_LANG_SOURCE([...])]
+
+commit a89f8cfaf11d0149b73ce40eca6e8a7f262f305a
+Author: Søren Sandmann Pedersen <ssp@redhat.com>
+Date: Fri Mar 25 15:09:17 2011 -0400
+
+ Replace argumentxs to composite functions with a pointer to a struct
+
+ This allows more information, such as flags or the composite region,
+ to be passed to the composite functions.
+
+commit 99e7d8fab546257ef729ea6db6e9beede984cec1
+Author: Søren Sandmann Pedersen <ssp@redhat.com>
+Date: Fri Mar 25 14:20:43 2011 -0400
+
+ In pixman-general.c rename image_parameters to {src, mask, dest}_image
+
+ All the fast paths generally use these names as well.
+
+commit 4d713e3120909d82e37b0405d035e85bbc8a61a9
+Author: Søren Sandmann Pedersen <ssp@redhat.com>
+Date: Fri Mar 25 14:17:08 2011 -0400
+
+ Replace instances of "dst_*" with "dest_*"
+
+ The variables in question were dst_x, dst_y, dst_image. The majority
+ of _x and _y uses were already dest_x and dest_y, while the majority
+ of _image uses were dst_image.
+
+commit 6aceb767aa6eea38ec3021263ca1d83aa9e0a3df
+Author: Søren Sandmann <ssp@redhat.com>
+Date: Sat May 28 12:32:35 2011 -0400
+
+ demos: Comment out some unused variables
+
+commit 4abe76432a59dec2e7978bfa4a01ad032178da0a
+Author: Søren Sandmann <ssp@redhat.com>
+Date: Sat May 28 11:56:32 2011 -0400
+
+ sse2: Delete some unused variables
+
+commit 5c60e1855b082b1a323319e1d0ba2d6f916fb3d5
+Author: Søren Sandmann <ssp@redhat.com>
+Date: Sat May 28 11:51:31 2011 -0400
+
+ mmx: Delete some unused variables
+
+commit 827e61333865dc94851eb79c8e640b103e3fd629
+Author: Andrea Canciani <ranma42@gmail.com>
+Date: Mon May 23 12:08:54 2011 +0200
+
+ Include noop in win32 builds
+
+commit 65b63728cc8ada802c9798e11e6fa92d21f2fbf8
+Author: Nis Martensen <nis.martensen@web.de>
+Date: Mon May 2 21:43:58 2011 +0200
+
+ Fix a few typos in pixman-combine.c.template
+
+ Some equations have too much multiplication with alpha.
+
+commit dd449a2a8ee1381fdc5297257917bc0786bf0ac4
+Author: Søren Sandmann Pedersen <ssp@redhat.com>
+Date: Sat Apr 23 10:26:49 2011 -0400
+
+ Move NOP src iterator into noop implementation.
+
+ The iterator for sources where neither RGB nor ALPHA is needed, really
+ belongs in the noop implementation.
+
+commit ba480882aa465d8414dc8a4472d89d94911af60a
+Author: Søren Sandmann Pedersen <ssp@redhat.com>
+Date: Sat Apr 23 10:24:41 2011 -0400
+
+ Move NULL iterator into pixman-noop.c
+
+ Iterating a NULL image returns NULL for all scanlines. We may as well
+ do this in the noop iterator.
+
+commit a4e984de19f7f2ca30b1d736cdd2dded91a75907
+Author: Søren Sandmann Pedersen <ssp@redhat.com>
+Date: Tue Feb 8 23:42:36 2011 -0500
+
+ Add a noop src iterator
+
+ When the image is a8r8g8b8 and not transformed, and the fetched
+ rectangle is within the image bounds, scanlines can be fetched by
+ simply returning a pointer instead of copying the bits.
+
+commit d4fff4a95921f734f26ef51953f4dddfcf423eab
+Author: Søren Sandmann Pedersen <ssp@redhat.com>
+Date: Mon Jan 24 12:16:03 2011 -0500
+
+ Move noop dest fetching to noop implementation
+
+ It will at some point become useful to have CPU specific destination
+ iterators. However, a problem with that, is that such iterators should
+ not be used if we can composite directly in the destination image.
+
+ By moving the noop destination iterator to the noop implementation, we
+ can ensure that it will be chosen before any CPU specific iterator.
+
+commit 13ce88f80095d0fa18330a23e03819368987e277
+Author: Søren Sandmann Pedersen <ssp@redhat.com>
+Date: Mon Jan 24 11:35:27 2011 -0500
+
+ Add a noop composite function for the DST operator
+
+ The DST operator doesn't actually do anything, so add a noop "fast
+ path" for it, instead of checking in pixman_image_composite32().
+
+ The performance tradeoff here is that we get rid of a test for DST in
+ the common case where the operator is not DST, in return for an extra
+ walk over the clip rectangles in the uncommon case where the operator
+ actually is DST.
+
+commit 8c76235f41b2ac70ce6e652dcd1cab975e1283a4
+Author: Søren Sandmann Pedersen <ssp@redhat.com>
+Date: Mon Jan 24 11:31:49 2011 -0500
+
+ Add a "noop" implementation.
+
+ This new implementation is ahead of all other implementations in the
+ fallback chain and is supposed to contain operations that are "noops",
+ ie., they don't require any work. For example, it might contain a
+ "fast path" for the DST operator that doesn't actually do anything or
+ an iterator for a8r8g8b8 that just returns a pointer into the image.
+
+commit 0f6a4d45886d64b244d57403609f0377b58cc7fb
+Author: Andrea Canciani <ranma42@gmail.com>
+Date: Thu May 5 10:17:08 2011 +0200
+
+ test: Fix compilation on win32
+
+ MSVC complains about uint32_t being used as an expression:
+
+ composite.c(902) : error C2275: 'uint32_t' : illegal use of this type
+ as an expression
+
+commit 838c2b593ec5ebbbf82de5b7790f5b68fd86bbc1
+Author: Dave Yeo <dave.r.yeo@gmail.com>
+Date: Mon May 9 12:38:44 2011 +0200
+
+ Check for working mmap()
+
+ OS/2 doesn't have a working mmap().
+
+commit c53625a36e28883684c3a6e640aa3656ecca7615
+Author: Søren Sandmann Pedersen <ssp@redhat.com>
+Date: Mon May 2 05:11:49 2011 -0400
+
+ Post-release version bump to 0.23.1
+
commit 918a544406df8f428056daff8a634ad6eadf67c9
Author: Søren Sandmann Pedersen <ssp@redhat.com>
Date: Mon May 2 05:06:33 2011 -0400
diff --git a/debian/changelog b/debian/changelog
index bba59bf..597c2e6 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,9 @@
+pixman (0.23.2-1) UNRELEASED; urgency=low
+
+ * New upstream release.
+
+ -- Cyril Brulebois <kibi@debian.org> Mon, 04 Jul 2011 22:46:51 +0200
+
pixman (0.22.0-1) unstable; urgency=low
* Team upload.
commit 6c4001a0e1cc0350147638ba941d23e129d00e0d
Author: Søren Sandmann Pedersen <ssp@redhat.com>
Date: Mon Jul 4 08:13:19 2011 -0400
Pre-release version bump to 0.23.2
diff --git a/configure.ac b/configure.ac
index 8ce9e19..7708c45 100644
--- a/configure.ac
+++ b/configure.ac
@@ -54,7 +54,7 @@ AC_PREREQ([2.57])
m4_define([pixman_major], 0)
m4_define([pixman_minor], 23)
-m4_define([pixman_micro], 1)
+m4_define([pixman_micro], 2)
m4_define([pixman_version],[pixman_major.pixman_minor.pixman_micro])
commit eff7c8efabe2da33edbf0bdc06e101352981286b
Author: Taekyun Kim <tkq.kim@samsung.com>
Date: Mon Jun 13 19:53:49 2011 +0900
Bilinear REPEAT_NORMAL source line extension for too short src_width
To avoid function call and other calculation overhead, extend source
scanline into temporary buffer when source width is too small.
Temporary buffer will be repeatedly accessed, so extension cost is
very small due to cache effect.
diff --git a/pixman/pixman-fast-path.h b/pixman/pixman-fast-path.h
index 8bc1d8a..e94591a 100644
--- a/pixman/pixman-fast-path.h
+++ b/pixman/pixman-fast-path.h
@@ -48,6 +48,11 @@
#define FLAG_HAVE_SOLID_MASK (1 << 1)
#define FLAG_HAVE_NON_SOLID_MASK (1 << 2)
+/* To avoid too short repeated scanline function calls, extend source
+ * scanlines having width less than below constant value.
+ */
+#define REPEAT_NORMAL_MIN_WIDTH 64
+
static force_inline pixman_bool_t
repeat (pixman_repeat_t repeat, int *c, int size)
{
@@ -692,6 +697,8 @@ fast_composite_scaled_bilinear ## scale_func_name (pixman_implementation_t *imp,
\
int src_width; \
pixman_fixed_t src_width_fixed; \
+ int max_x; \
+ pixman_bool_t need_src_extension; \
\
PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, dst_type_t, dst_stride, dst_line, 1); \
if (flags & FLAG_HAVE_SOLID_MASK) \
@@ -743,7 +750,25 @@ fast_composite_scaled_bilinear ## scale_func_name (pixman_implementation_t *imp,
\
if (PIXMAN_REPEAT_ ## repeat_mode == PIXMAN_REPEAT_NORMAL) \
{ \
- src_width = src_image->bits.width; \
+ vx = v.vector[0]; \
+ repeat (PIXMAN_REPEAT_NORMAL, &vx, pixman_int_to_fixed(src_image->bits.width)); \
+ max_x = pixman_fixed_to_int (vx + (width - 1) * unit_x) + 1; \
+ \
+ if (src_image->bits.width < REPEAT_NORMAL_MIN_WIDTH) \
+ { \
+ src_width = 0; \
+ \
+ while (src_width < REPEAT_NORMAL_MIN_WIDTH && src_width <= max_x) \
+ src_width += src_image->bits.width; \
+ \
+ need_src_extension = TRUE; \
+ } \
+ else \
+ { \
+ src_width = src_image->bits.width; \
+ need_src_extension = FALSE; \
+ } \
+ \
src_width_fixed = pixman_int_to_fixed (src_width); \
} \
\
@@ -901,22 +926,41 @@ fast_composite_scaled_bilinear ## scale_func_name (pixman_implementation_t *imp,
src_type_t * src_line_bottom; \
src_type_t buf1[2]; \
src_type_t buf2[2]; \
+ src_type_t extended_src_line0[REPEAT_NORMAL_MIN_WIDTH*2]; \
+ src_type_t extended_src_line1[REPEAT_NORMAL_MIN_WIDTH*2]; \
+ int i, j; \
\
repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image->bits.height); \
repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image->bits.height); \
src_line_top = src_first_line + src_stride * y1; \
src_line_bottom = src_first_line + src_stride * y2; \
\
+ if (need_src_extension) \
+ { \
+ for (i=0; i<src_width;) \
+ { \
+ for (j=0; j<src_image->bits.width; j++, i++) \
+ { \
+ extended_src_line0[i] = src_line_top[j]; \
+ extended_src_line1[i] = src_line_bottom[j]; \
+ } \
+ } \
+ \
+ src_line_top = &extended_src_line0[0]; \
+ src_line_bottom = &extended_src_line1[0]; \
+ } \
+ \
/* Top & Bottom wrap around buffer */ \
- buf1[0] = src_line_top[src_image->bits.width - 1]; \
+ buf1[0] = src_line_top[src_width - 1]; \
buf1[1] = src_line_top[0]; \
- buf2[0] = src_line_bottom[src_image->bits.width - 1]; \
+ buf2[0] = src_line_bottom[src_width - 1]; \
buf2[1] = src_line_bottom[0]; \
\
width_remain = width; \
\
while (width_remain > 0) \
{ \
+ /* We use src_width_fixed because it can make vx in original source range */ \
repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); \
\
/* Wrap around part */ \
commit 828794d328e7ad1efc860baee8d6e72450b486b9
Author: Taekyun Kim <tkq.kim@samsung.com>
Date: Wed Jun 8 17:17:42 2011 +0900
Enable REPEAT_NORMAL bilinear fast path entries
diff --git a/pixman/pixman-fast-path.h b/pixman/pixman-fast-path.h
index ca497ad..8bc1d8a 100644
--- a/pixman/pixman-fast-path.h
+++ b/pixman/pixman-fast-path.h
@@ -1027,6 +1027,17 @@ fast_composite_scaled_bilinear ## scale_func_name (pixman_implementation_t *imp,
fast_composite_scaled_bilinear_ ## func ## _cover ## _ ## op, \
}
+#define SIMPLE_BILINEAR_FAST_PATH_NORMAL(op,s,d,func) \
+ { PIXMAN_OP_ ## op, \
+ PIXMAN_ ## s, \
+ (SCALED_BILINEAR_FLAGS | \
+ FAST_PATH_NORMAL_REPEAT | \
+ FAST_PATH_X_UNIT_POSITIVE), \
+ PIXMAN_null, 0, \
+ PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS, \
+ fast_composite_scaled_bilinear_ ## func ## _normal ## _ ## op, \
+ }
+
#define SIMPLE_BILINEAR_A8_MASK_FAST_PATH_PAD(op,s,d,func) \
{ PIXMAN_OP_ ## op, \
PIXMAN_ ## s, \
@@ -1058,6 +1069,17 @@ fast_composite_scaled_bilinear ## scale_func_name (pixman_implementation_t *imp,
fast_composite_scaled_bilinear_ ## func ## _cover ## _ ## op, \
}
+#define SIMPLE_BILINEAR_A8_MASK_FAST_PATH_NORMAL(op,s,d,func) \
+ { PIXMAN_OP_ ## op, \
+ PIXMAN_ ## s, \
+ (SCALED_BILINEAR_FLAGS | \
+ FAST_PATH_NORMAL_REPEAT | \
+ FAST_PATH_X_UNIT_POSITIVE), \
+ PIXMAN_a8, MASK_FLAGS (a8, FAST_PATH_UNIFIED_ALPHA), \
+ PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS, \
+ fast_composite_scaled_bilinear_ ## func ## _normal ## _ ## op, \
+ }
+
#define SIMPLE_BILINEAR_SOLID_MASK_FAST_PATH_PAD(op,s,d,func) \
{ PIXMAN_OP_ ## op, \
PIXMAN_ ## s, \
@@ -1089,20 +1111,34 @@ fast_composite_scaled_bilinear ## scale_func_name (pixman_implementation_t *imp,
fast_composite_scaled_bilinear_ ## func ## _cover ## _ ## op, \
}
+#define SIMPLE_BILINEAR_SOLID_MASK_FAST_PATH_NORMAL(op,s,d,func) \
+ { PIXMAN_OP_ ## op, \
+ PIXMAN_ ## s, \
+ (SCALED_BILINEAR_FLAGS | \
+ FAST_PATH_NORMAL_REPEAT | \
+ FAST_PATH_X_UNIT_POSITIVE), \
+ PIXMAN_solid, MASK_FLAGS (solid, FAST_PATH_UNIFIED_ALPHA), \
+ PIXMAN_ ## d, FAST_PATH_STD_DEST_FLAGS, \
+ fast_composite_scaled_bilinear_ ## func ## _normal ## _ ## op, \
+ }
+
/* Prefer the use of 'cover' variant, because it is faster */
#define SIMPLE_BILINEAR_FAST_PATH(op,s,d,func) \
SIMPLE_BILINEAR_FAST_PATH_COVER (op,s,d,func), \
SIMPLE_BILINEAR_FAST_PATH_NONE (op,s,d,func), \
- SIMPLE_BILINEAR_FAST_PATH_PAD (op,s,d,func)
+ SIMPLE_BILINEAR_FAST_PATH_PAD (op,s,d,func), \
+ SIMPLE_BILINEAR_FAST_PATH_NORMAL (op,s,d,func)
#define SIMPLE_BILINEAR_A8_MASK_FAST_PATH(op,s,d,func) \
SIMPLE_BILINEAR_A8_MASK_FAST_PATH_COVER (op,s,d,func), \
SIMPLE_BILINEAR_A8_MASK_FAST_PATH_NONE (op,s,d,func), \
- SIMPLE_BILINEAR_A8_MASK_FAST_PATH_PAD (op,s,d,func)
+ SIMPLE_BILINEAR_A8_MASK_FAST_PATH_PAD (op,s,d,func), \
+ SIMPLE_BILINEAR_A8_MASK_FAST_PATH_NORMAL (op,s,d,func)
#define SIMPLE_BILINEAR_SOLID_MASK_FAST_PATH(op,s,d,func) \
SIMPLE_BILINEAR_SOLID_MASK_FAST_PATH_COVER (op,s,d,func), \
SIMPLE_BILINEAR_SOLID_MASK_FAST_PATH_NONE (op,s,d,func), \
- SIMPLE_BILINEAR_SOLID_MASK_FAST_PATH_PAD (op,s,d,func)
+ SIMPLE_BILINEAR_SOLID_MASK_FAST_PATH_PAD (op,s,d,func), \
+ SIMPLE_BILINEAR_SOLID_MASK_FAST_PATH_NORMAL (op,s,d,func)
#endif
commit 1161b3f9edb6f5c396438b79f2df3218ea8d194e
Author: Taekyun Kim <tkq.kim@samsung.com>
Date: Wed Jun 8 17:14:29 2011 +0900
ARM: Add REPEAT_NORMAL functions to bilinear BIND macros
Now bilinear template support REPEAT_NORMAL, so functions for that
is added to PIXMAN_ARM_BIND_SCALED_BILINEAR_ macros. Fast path
entries are not enabled yet.
diff --git a/pixman/pixman-arm-common.h b/pixman/pixman-arm-common.h
index 524ae70..f1d212c 100644
--- a/pixman/pixman-arm-common.h
+++ b/pixman/pixman-arm-common.h
@@ -354,7 +354,11 @@ FAST_BILINEAR_MAINLOOP_COMMON (cputype##_##name##_none_##op, \
src_type, uint32_t, dst_type, NONE, FLAG_NONE) \
FAST_BILINEAR_MAINLOOP_COMMON (cputype##_##name##_pad_##op, \
scaled_bilinear_scanline_##cputype##_##name##_##op, \
- src_type, uint32_t, dst_type, PAD, FLAG_NONE)
+ src_type, uint32_t, dst_type, PAD, FLAG_NONE) \
+FAST_BILINEAR_MAINLOOP_COMMON (cputype##_##name##_normal_##op, \
+ scaled_bilinear_scanline_##cputype##_##name##_##op, \
+ src_type, uint32_t, dst_type, NORMAL, \
+ FLAG_NONE)
#define PIXMAN_ARM_BIND_SCALED_BILINEAR_SRC_A8_DST(flags, cputype, name, op, \
@@ -402,6 +406,11 @@ FAST_BILINEAR_MAINLOOP_COMMON (cputype##_##name##_none_##op, \
FAST_BILINEAR_MAINLOOP_COMMON (cputype##_##name##_pad_##op, \
scaled_bilinear_scanline_##cputype##_##name##_##op, \
src_type, uint8_t, dst_type, PAD, \
+ FLAG_HAVE_NON_SOLID_MASK) \
+FAST_BILINEAR_MAINLOOP_COMMON (cputype##_##name##_normal_##op, \
+ scaled_bilinear_scanline_##cputype##_##name##_##op, \
+ src_type, uint8_t, dst_type, NORMAL, \
FLAG_HAVE_NON_SOLID_MASK)
+
#endif
commit ebd2f06d96ee91f9f7f13b906ae328862da7dde8
Author: Taekyun Kim <tkq.kim@samsung.com>
Date: Wed Jun 8 17:11:24 2011 +0900
sse2: Declare bilinear src_8888_8888 REPEAT_NORMAL composite function
Now bilinear template support REPEAT_NORMAL, so declare composite
functions using it. Function is just declared not used yet.
diff --git a/pixman/pixman-sse2.c b/pixman/pixman-sse2.c
index dd15ccd..3d51c2f 100644
--- a/pixman/pixman-sse2.c
+++ b/pixman/pixman-sse2.c
@@ -5394,6 +5394,11 @@ FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_8888_none_SRC,
scaled_bilinear_scanline_sse2_8888_8888_SRC,
uint32_t, uint32_t, uint32_t,
NONE, FLAG_NONE)
+FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_8888_normal_SRC,
+ scaled_bilinear_scanline_sse2_8888_8888_SRC,
+ uint32_t, uint32_t, uint32_t,
+ NORMAL, FLAG_NONE)
+
static const pixman_fast_path_t sse2_fast_paths[] =
{
commit 7e22b2f7824f844076e1bb1fb26a6ec5e5d029cd
Author: Taekyun Kim <tkq.kim@samsung.com>
Date: Wed Jun 8 15:58:01 2011 +0900
REPEAT_NORMAL support for bilinear fast path template
The basic idea is to break down normal repeat into a set of
non-repeat scanline compositions and stitching them together.
Bilinear may interpolate last and first pixels of source scanline.
In this case, we can use temporary wrap around buffer.
diff --git a/pixman/pixman-fast-path.h b/pixman/pixman-fast-path.h
index e00b1a6..ca497ad 100644
--- a/pixman/pixman-fast-path.h
+++ b/pixman/pixman-fast-path.h
@@ -690,6 +690,9 @@ fast_composite_scaled_bilinear ## scale_func_name (pixman_implementation_t *imp,
const mask_type_t *mask = &solid_mask; \
int src_stride, mask_stride, dst_stride; \
\
+ int src_width; \
+ pixman_fixed_t src_width_fixed; \
+ \
PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, dst_type_t, dst_stride, dst_line, 1); \
if (flags & FLAG_HAVE_SOLID_MASK) \
{ \
@@ -738,6 +741,12 @@ fast_composite_scaled_bilinear ## scale_func_name (pixman_implementation_t *imp,
v.vector[0] += left_pad * unit_x; \
} \
\
+ if (PIXMAN_REPEAT_ ## repeat_mode == PIXMAN_REPEAT_NORMAL) \
+ { \
+ src_width = src_image->bits.width; \
+ src_width_fixed = pixman_int_to_fixed (src_width); \
+ } \
+ \
while (--height >= 0) \
{ \
int weight1, weight2; \
@@ -884,6 +893,87 @@ fast_composite_scaled_bilinear ## scale_func_name (pixman_implementation_t *imp,
buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, TRUE); \
} \
} \
+ else if (PIXMAN_REPEAT_ ## repeat_mode == PIXMAN_REPEAT_NORMAL) \
+ { \
+ int32_t num_pixels; \
+ int32_t width_remain; \
+ src_type_t * src_line_top; \
+ src_type_t * src_line_bottom; \
+ src_type_t buf1[2]; \
+ src_type_t buf2[2]; \
+ \
+ repeat (PIXMAN_REPEAT_NORMAL, &y1, src_image->bits.height); \
+ repeat (PIXMAN_REPEAT_NORMAL, &y2, src_image->bits.height); \
+ src_line_top = src_first_line + src_stride * y1; \
+ src_line_bottom = src_first_line + src_stride * y2; \
+ \
+ /* Top & Bottom wrap around buffer */ \
+ buf1[0] = src_line_top[src_image->bits.width - 1]; \
+ buf1[1] = src_line_top[0]; \
+ buf2[0] = src_line_bottom[src_image->bits.width - 1]; \
+ buf2[1] = src_line_bottom[0]; \
+ \
+ width_remain = width; \
+ \
+ while (width_remain > 0) \
+ { \
+ repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); \
+ \
+ /* Wrap around part */ \
+ if (pixman_fixed_to_int (vx) == src_width - 1) \
+ { \
+ /* for positive unit_x \
+ * num_pixels = max(n) + 1, where vx + n*unit_x < src_width_fixed \
+ * \
+ * vx is in range [0, src_width_fixed - pixman_fixed_e] \
+ * So we are safe from overflow. \
+ */ \
+ num_pixels = ((src_width_fixed - vx - pixman_fixed_e) / unit_x) + 1; \
+ \
+ if (num_pixels > width_remain) \
+ num_pixels = width_remain; \
+ \
+ scanline_func (dst, mask, buf1, buf2, num_pixels, \
+ weight1, weight2, pixman_fixed_frac(vx), \
+ unit_x, src_width_fixed, FALSE); \
+ \
+ width_remain -= num_pixels; \
+ vx += num_pixels * unit_x; \
+ dst += num_pixels; \
+ \
+ if (flags & FLAG_HAVE_NON_SOLID_MASK) \
+ mask += num_pixels; \
+ \
+ repeat (PIXMAN_REPEAT_NORMAL, &vx, src_width_fixed); \
+ } \
+ \
+ /* Normal scanline composite */ \
+ if (pixman_fixed_to_int (vx) != src_width - 1 && width_remain > 0) \
+ { \
+ /* for positive unit_x \
+ * num_pixels = max(n) + 1, where vx + n*unit_x < (src_width_fixed - 1) \
+ * \
+ * vx is in range [0, src_width_fixed - pixman_fixed_e] \
+ * So we are safe from overflow here. \
+ */ \
+ num_pixels = ((src_width_fixed - pixman_fixed_1 - vx - pixman_fixed_e) \
+ / unit_x) + 1; \
+ \
+ if (num_pixels > width_remain) \
+ num_pixels = width_remain; \
+ \
+ scanline_func (dst, mask, src_line_top, src_line_bottom, num_pixels, \
+ weight1, weight2, vx, unit_x, src_width_fixed, FALSE); \
+ \
+ width_remain -= num_pixels; \
+ vx += num_pixels * unit_x; \
+ dst += num_pixels; \
+ \
+ if (flags & FLAG_HAVE_NON_SOLID_MASK) \
+ mask += num_pixels; \
+ } \
+ } \
+ } \
else \
{ \
scanline_func (dst, mask, src_first_line + src_stride * y1, \
commit 2f025bad436982a2b1c54d7cb49b426ebf198350
Author: Taekyun Kim <tkq.kim@samsung.com>
Date: Wed Jun 8 15:37:31 2011 +0900
Replace boolean arguments with flags for bilinear fast path template
By replacing boolean arguments with flags, the code can be more
readable and flags can be extended to do some more things later.
Currently following flags are defined.
FLAG_NONE
- No flags are turned on.
FLAG_HAVE_SOLID_MASK
- Template will generate solid mask composite functions.
FLAG_HAVE_NON_SOLID_MASK
- Template will generate bits mask composite functions.
FLAG_HAVE_SOLID_MASK and FLAG_NON_SOLID_MASK should be mutually
exclusive.
diff --git a/pixman/pixman-arm-common.h b/pixman/pixman-arm-common.h
index f7a10c4..524ae70 100644
--- a/pixman/pixman-arm-common.h
+++ b/pixman/pixman-arm-common.h
@@ -348,13 +348,13 @@ scaled_bilinear_scanline_##cputype##_##name##_##op ( \
\
FAST_BILINEAR_MAINLOOP_COMMON (cputype##_##name##_cover_##op, \
scaled_bilinear_scanline_##cputype##_##name##_##op, \
- src_type, uint32_t, dst_type, COVER, FALSE, FALSE) \
+ src_type, uint32_t, dst_type, COVER, FLAG_NONE) \
FAST_BILINEAR_MAINLOOP_COMMON (cputype##_##name##_none_##op, \
scaled_bilinear_scanline_##cputype##_##name##_##op, \
- src_type, uint32_t, dst_type, NONE, FALSE, FALSE) \
+ src_type, uint32_t, dst_type, NONE, FLAG_NONE) \
FAST_BILINEAR_MAINLOOP_COMMON (cputype##_##name##_pad_##op, \
scaled_bilinear_scanline_##cputype##_##name##_##op, \
- src_type, uint32_t, dst_type, PAD, FALSE, FALSE)
+ src_type, uint32_t, dst_type, PAD, FLAG_NONE)
#define PIXMAN_ARM_BIND_SCALED_BILINEAR_SRC_A8_DST(flags, cputype, name, op, \
@@ -393,12 +393,15 @@ scaled_bilinear_scanline_##cputype##_##name##_##op ( \
\
FAST_BILINEAR_MAINLOOP_COMMON (cputype##_##name##_cover_##op, \
scaled_bilinear_scanline_##cputype##_##name##_##op, \
- src_type, uint8_t, dst_type, COVER, TRUE, FALSE) \
+ src_type, uint8_t, dst_type, COVER, \
+ FLAG_HAVE_NON_SOLID_MASK) \
FAST_BILINEAR_MAINLOOP_COMMON (cputype##_##name##_none_##op, \
scaled_bilinear_scanline_##cputype##_##name##_##op, \
- src_type, uint8_t, dst_type, NONE, TRUE, FALSE) \
+ src_type, uint8_t, dst_type, NONE, \
+ FLAG_HAVE_NON_SOLID_MASK) \
FAST_BILINEAR_MAINLOOP_COMMON (cputype##_##name##_pad_##op, \
scaled_bilinear_scanline_##cputype##_##name##_##op, \
- src_type, uint8_t, dst_type, PAD, TRUE, FALSE)
+ src_type, uint8_t, dst_type, PAD, \
+ FLAG_HAVE_NON_SOLID_MASK)
#endif
diff --git a/pixman/pixman-fast-path.h b/pixman/pixman-fast-path.h
index fcbaa95..e00b1a6 100644
--- a/pixman/pixman-fast-path.h
+++ b/pixman/pixman-fast-path.h
@@ -30,6 +30,24 @@
#define PIXMAN_REPEAT_COVER -1
+/* Flags describing input parameters to fast path macro template.
+ * Turning on some flag values may indicate that
+ * "some property X is available so template can use this" or
+ * "some property X should be handled by template".
+ *
+ * FLAG_HAVE_SOLID_MASK
+ * Input mask is solid so template should handle this.
+ *
+ * FLAG_HAVE_NON_SOLID_MASK
+ * Input mask is bits mask so template should handle this.
+ *
+ * FLAG_HAVE_SOLID_MASK and FLAG_HAVE_NON_SOLID_MASK are mutually
+ * exclusive. (It's not allowed to turn both flags on)
+ */
+#define FLAG_NONE (0)
+#define FLAG_HAVE_SOLID_MASK (1 << 1)
+#define FLAG_HAVE_NON_SOLID_MASK (1 << 2)
+
static force_inline pixman_bool_t
repeat (pixman_repeat_t repeat, int *c, int size)
{
@@ -651,7 +669,7 @@ bilinear_pad_repeat_get_scanline_bounds (int32_t source_image_width,
* multiplication instructions.
*/
#define FAST_BILINEAR_MAINLOOP_INT(scale_func_name, scanline_func, src_type_t, mask_type_t, \
- dst_type_t, repeat_mode, have_mask, mask_is_solid) \
+ dst_type_t, repeat_mode, flags) \
static void \
fast_composite_scaled_bilinear ## scale_func_name (pixman_implementation_t *imp, \
pixman_composite_info_t *info) \
@@ -673,19 +691,17 @@ fast_composite_scaled_bilinear ## scale_func_name (pixman_implementation_t *imp,
int src_stride, mask_stride, dst_stride; \
\
PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, dst_type_t, dst_stride, dst_line, 1); \
- if (have_mask) \
+ if (flags & FLAG_HAVE_SOLID_MASK) \
{ \
- if (mask_is_solid) \
- { \
- solid_mask = _pixman_image_get_solid (imp, mask_image, dest_image->bits.format); \
- mask_stride = 0; \
- } \
- else \
- { \
- PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, mask_type_t, \
- mask_stride, mask_line, 1); \
- } \
+ solid_mask = _pixman_image_get_solid (imp, mask_image, dest_image->bits.format); \
+ mask_stride = 0; \
} \
+ else if (flags & FLAG_HAVE_NON_SOLID_MASK) \
+ { \
+ PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, mask_type_t, \
+ mask_stride, mask_line, 1); \
+ } \
+ \
/* pass in 0 instead of src_x and src_y because src_x and src_y need to be \
* transformed from destination space to source space */ \
PIXMAN_IMAGE_GET_LINE (src_image, 0, 0, src_type_t, src_stride, src_first_line, 1); \
@@ -728,7 +744,7 @@ fast_composite_scaled_bilinear ## scale_func_name (pixman_implementation_t *imp,
dst = dst_line; \
dst_line += dst_stride; \
vx = v.vector[0]; \
- if (have_mask && !mask_is_solid) \
+ if (flags & FLAG_HAVE_NON_SOLID_MASK) \
{ \
mask = mask_line; \
mask_line += mask_stride; \
@@ -766,7 +782,7 @@ fast_composite_scaled_bilinear ## scale_func_name (pixman_implementation_t *imp,
scanline_func (dst, mask, \
buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, FALSE); \
dst += left_pad; \
- if (have_mask && !mask_is_solid) \
+ if (flags & FLAG_HAVE_NON_SOLID_MASK) \
mask += left_pad; \
} \
if (width > 0) \
@@ -774,7 +790,7 @@ fast_composite_scaled_bilinear ## scale_func_name (pixman_implementation_t *imp,
scanline_func (dst, mask, \
src1, src2, width, weight1, weight2, vx, unit_x, 0, FALSE); \
dst += width; \
- if (have_mask && !mask_is_solid) \
+ if (flags & FLAG_HAVE_NON_SOLID_MASK) \
mask += width; \
} \
if (right_pad > 0) \
@@ -821,7 +837,7 @@ fast_composite_scaled_bilinear ## scale_func_name (pixman_implementation_t *imp,
scanline_func (dst, mask, \
buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, TRUE); \
dst += left_pad; \
- if (have_mask && !mask_is_solid) \
+ if (flags & FLAG_HAVE_NON_SOLID_MASK) \
mask += left_pad; \
} \
if (left_tz > 0) \
@@ -834,7 +850,7 @@ fast_composite_scaled_bilinear ## scale_func_name (pixman_implementation_t *imp,
buf1, buf2, left_tz, weight1, weight2, \
pixman_fixed_frac (vx), unit_x, 0, FALSE); \
dst += left_tz; \
- if (have_mask && !mask_is_solid) \
+ if (flags & FLAG_HAVE_NON_SOLID_MASK) \
mask += left_tz; \
vx += left_tz * unit_x; \
} \
@@ -843,7 +859,7 @@ fast_composite_scaled_bilinear ## scale_func_name (pixman_implementation_t *imp,
scanline_func (dst, mask, \
src1, src2, width, weight1, weight2, vx, unit_x, 0, FALSE); \
dst += width; \
- if (have_mask && !mask_is_solid) \
Reply to: