Move region computation out of the loop in do_composite()

We only need to compute the composite region once, not on every
iteration.

Move get_image_info() out of the loop in do_composite

The computation of image formats and flags is invariant to the loop,
so it can all be moved out.

Manually inline _pixman_run_fast_path()

Move all of the code into do_composite().

Move compositing functionality from pixman-utils.c into pixman.c

_pixman_run_fast_path() and pixman_compute_composite_region() are both
moved to pixman-image, since at this point that's the only place they
are being called from.

Move compositing to its own function, do_composite()

Optimize for the common case wrt. the workaround.

In the common case no images need the workaround, so we check for that
first, and only if an image does need a workaround do we check which
one of the images actually need it.

Eliminate all the composite methods.

They are no longer necessary because we will just walk the fast path
tables, and the general composite path is treated as another fast
path.

This unfortunately means that sse2_composite() can no longer be
responsible for realigning the stack to 16 bytes, so we have to move
that to pixman_image_composite().

Delete unused _pixman_walk_composite_region() function

Don't call _pixman_implementation_composite() anymore.

Instead just call _pixman_run_fast_path(). Since we view
general_composite() as a fast path now, we know that it will find
*some* compositing routine.

Delete unused sources_cover() function

Store a pointer to the array of fast paths in the implementation struct.

Also add an empty fast path table to the vmx implementation, so that
we can assume sure the pointer is never NULL.

Make fast_composite_scaled_nearest() another fast path.

This requires another couple of flags

     FAST_PATH_SCALE_TRANSFORM
     FAST_PATH_NEAREST_FILTER

Make general_composite_rect() just another fast path.

We introduce a new PIXMAN_OP_any fake operator and a PIXMAN_any fake
format that match anything. Then general_composite_rect() can be used
as another fast path.

Because general_composite_rect() does not require the sources to cover
the clip region, we add a new flag FAST_PATH_COVERS_CLIP which is part
of the set of standard flags for fast paths.

Because this flag cannot be computed until after the clip region is
available, we have to call pixman_compute_composite_region32() before
checking for fast paths. This will resolve itself when we get to the
point where _pixman_run_fast_path() is only called once per composite
operation.

Post-release version bump

Pre-release version bump

Once unrolled version of fast_path_composite_nearest_scaled()

Separate out the fetching and combining code in two inline
functions. Then do two pixels per iteration.

Generalize and optimize fast_composite_src_scaled_nearest()

- Make it work for PIXMAN_OP_OVER

- Split repeat computation for x and y, and only the x part in the
  inner loop.

- Move stride multiplication outside of inner loop

Merge branch 'bitmasks'

Makefile.am: Remove 'check' from release-check

It's already included in distcheck.

Turn off asserts in development snapshots (bug 26314).

There is not much real benefit in having asserts turned on in
snapshots because it doesn't lead to any new bug reports, just to
people not installing development snapshots since they case X server
crashes. So just turn them off.

While we are at it, limit the number of messages to stderr to 5
instead of 50.

ARM: Remove any use of environment variables for cpu features detection

Old code assumed that all ARMv7 processors support NEON instructions
unless overrided by environment variable ARM_TRUST_HWCAP. This causes
X server to die with SIGILL if NEON support is disabled in the kernel
configuration. Additionally, ARMv7 processors lacking NEON unit are
going to become available eventually.

The problem was reported by user bearsh at irc.freenode.net #gentoo-embedded

Add pixman_image_get_destroy_data()

This way you can get back user data that was set using
pixman_image_set_destroy_function().

Add extern "C" guards for c++

Move checks for src/mask repeat right before walking the region.

Also add a couple of additional checks to the src/mask repeat check.

Compute src, mask, dest flags and base fast path decisions on them.

This makes sets the stage for caching the information by image instead
of computing it on each composite invocation.

This patch also computes format codes for images such as PIXMAN_solid,
so that we can no longer end up in the situation that a fast path is
selected for a 1x1 solid image, when that fast path doesn't actually
understand repeating.

Add src_, mask_, and dest_flags fields to fast path arrays

Update all the fast path tables to match using a new
PIXMAN_STD_FAST_PATH macro.

For now, use 0 for the flags fields.

Move calls to source_is_fastpathable() into get_source_format()

Fold get_fast_path() into _pixman_run_fast_path()

Also factor out the source format code computation to its own
function.

Consolidate the source and mask sanity checks in a function

Move pixbuf checks after src_format and mask_format have been computed.

Move the sanity checks for src, mask and destination into get_fast_path()

Turn some uint16_t variables to int32_t in the fast paths.

This is necessary now that we have a 32 bit version of
pixman_image_composite().

Implement get_scanline_64() correctly for solid fill images.

Previously they would be evaluated at 8 bits and then expanded.

Make pixman_image_fill_rectangles() call pixman_image_fill_boxes()

Avoids duplication of code

Add pixman_image_fill_boxes() API

It's basically the 32bit version of pixman_image_fill_rectangles(), just
with a saner data type.

Add pixman_image_composite32()

This is equal to pixman_image_composite(), just with 32bit parameters.
pixman_image_composite() now just calls pixman_image_composite32()

Make region argument to pixman_region(32)_init_rects() const

No indenting of the header to keep git blame working

Fix typo

Fix some warnings

Post-release version bump

Pre-release version bump

bits: Print an error if someone tries to create an image with bpp < depth

Something in the X server apparently does this.

When fetching from an alpha map, replace the alpha channel of the image

Previously it would be multiplied onto the image pixel, but the Render
specification is pretty clear that the alpha map should be used
*instead* of any alpha channel within the image.

This makes the assumption that the pixels in the image are already
premultiplied with the alpha channel from the alpha map. If we don't
make this assumption and the image has an alpha channel of its own, we
would have to first unpremultiply that pixel, and then premultiply the
alpha value onto the color channels, and then replace the alpha
channel.

pixman_image_validate() needs to also validate the alpha map.

This is the other half of bug 25950.

When fetching from an alpha map, use the alpha map's fetch function.

Don't use the one from the image. This is the first half of bug 25950.

test: Add new alphamap test program.

This program demonstrates three bugs relating to alpha maps:

- When fetching from an alpha map into 32 bit intermediates, we use
  the fetcher from the image, and not the one from the alpha map.

- For 64 bit intermediates we call fetch_pixel_generic_lossy_32()
  which then calls fetch_pixel_raw_64, which is NULL because alpha
  images are never validated.

- The alpha map should be used *in place* of any existing alpha
  channel, but we are actually multiplying it onto the image.

fetch-test: Fix spelling error (pallete -> palette)

Update Sun license notices to current X.Org standard form

Signed-off-by: Alan Coopersmith <alan.coopersmith@sun.com>

fetch-test: Various formatting fixes

Interpret the angle of a conical gradient in degrees.

The conical gradient angle's fixed point degrees to
radians conversion code is missing a factor of pi.

region: Enable or disable fatal errors and selfchecks based on version number

There is a couple of bugs in bugzilla where bugs in the X server
triggered asserts in the pixman region code. It is probably better to
let the X server survive this. (In fact, I thought I had disabled them
for 0.16.0, but apparently not).

The patch below uses these rules:

    - In _stable_ pixman releases, assertions and selfchecks are turned
      off. Assertions, so that the X server doesn't die. Selfchecks,
      for performance reasons.

    - In _unstable_ pixman releases, both assertions and selfcheck are
      turned on. These releases are what get added to development
      distributions such as rawhide, so we want as much self-checking
      as possible.

    - In _random git checkouts_, assertions are enabled, so that bugs
      are caught, but selfchecks are disabled so that you can use them
      for performance work without having to fiddle with turning
      selfchecks off.

Some minor formatting fixes.

arm-simd: Whitespace fixes

mmx: Eliminate trailing whitespace.

Add 'check' to release-check make target

Reorder tests so that they fastest ones run first.

Build tests and run non-GTK+ ones on `make check`

Setting TESTS will run the tests on `make check`

Bug 25131

ARM: added 'neon_combine_add_u' function

ARM: added 'neon_combine_over_u' function

ARM: macro template for single scanline compositing functions

Existing template already supports 2D images processing,
but pixman also needs some NEON optimized functions for
improving performance when compositing is decoupled
into "fetch -> process -> store" stages and done via
temporary scanline buffer. That's why a new simplified
template which deals only with the generation of single
scanline processing functions is handy.

Use canonical pixman license notice for recently added ARM NEON assembly files

ARM: added 'neon_composite_src_pixbuf_8888' fast path

This is ARM NEON optimized conversion of native RGBA format used by
GTK/GDK into native 32bpp RGBA format used by cairo/pixman.

ARM: added 'neon_composite_src_0888_0565_rev' fast path

This is ARM NEON optimized conversion of native RGB format used by
GTK/GDK into r5g6b5 format.

ARM: added 'neon_src_0888_8888_rev' fast path

This is ARM NEON optimized conversion of native RGB format used by
GTK/GDK into native 32bpp RGB format used by cairo/pixman.

ARM: added 'neon_composite_over_n_8888' fast path

ARM: added 'neon_composite_over_n_0565' fast path

ARM: added 'neon_composite_src_0565_8888' fast path

ARM: added 'neon_composite_add_8888_8888_8888' fast path

ARM: added 'neon_composite_add_8888_8888' fast path

ARM: added 'neon_composite_over_8888_8_8888' fast path

ARM: added 'neon_composite_over_8888_8888_8888' fast path

ARM: minor source formatting changes

Now it's a bit harder to exceed 80 characters line limit
when binding assembly functions.

ARM: added '.arch armv7a' directive to NEON assembly file

This fix prevents build failure due to not accepting PLD instruction when
compiling for armv4 cpu with the relevant -mcpu/-march options set in CFLAGS.

Make test program not throw warnings about undefined variables

Fix bug that prevented pixman_fill MMX and SSE paths for 16 and 8bpp

ARM: NEON optimized pixman_blt

NEON unit has fast access to L1/L2 caches and even simple
copy of memory buffers using NEON provides more than 1.5x
performance improvement on ARM Cortex-A8.

test: support for testing pixbuf fast path functions in blitters-test

Remove nonexistant function from header

Post-release version bump

Pre-release version bump

Remove stray semicolon from blitters-test.c

Pointed out by scottmc2@gmail.com in bug 25137.

C fast path function for 'over_n_1_0565'

This function is needed to improve performance of xfce4 terminal when
using bitmap fonts and running with 16bpp desktop. Some other applications
may potentially benefit too.

After applying this patch, top functions from Xorg process in
oprofile log change from

samples  %        image name               symbol name
13296    29.1528  libpixman-1.so.0.17.1    combine_over_u
6452     14.1466  libpixman-1.so.0.17.1    fetch_scanline_r5g6b5
5516     12.0944  libpixman-1.so.0.17.1    fetch_scanline_a1
2273      4.9838  libpixman-1.so.0.17.1    store_scanline_r5g6b5
1741      3.8173  libpixman-1.so.0.17.1    fast_composite_add_1000_1000
1718      3.7669  libc-2.9.so              memcpy

to

samples  %        image name               symbol name
5594     14.7033  libpixman-1.so.0.17.1    fast_composite_over_n_1_0565
4323     11.3626  libc-2.9.so              memcpy
3695      9.7119  libpixman-1.so.0.17.1    fast_composite_add_1000_1000

when scrolling text in terminal (reading man page).

Delete the flags field from fast_path_info_t

Eliminate NEED_PIXBUF flag.

Instead introduce two new fake formats

PIXMAN_pixbuf
PIXMAN_rpixbuf

and compute whether the source and mask have them in
find_fast_path(). This lead to some duplicate entries in the fast path
tables that could then be removed.

Compute src_format outside the fast path loop.

Inside the loop all we have to do is check that the formats match.

Eliminate the NEED_COMPONENT_ALPHA flag.

Instead introduce two new fake formats

PIXMAN_a8r8g8b8_ca
PIXMAN_a8b8g8r8_ca

that are used in the fast path tables for this case.

Eliminate the NEED_SOLID_MASK flag

This flag was used to indicate that the mask was solid while still
allowing a specific format to be required. However, there is not
actually any need for this because the fast paths all used
_pixman_image_get_solid() which already allowed arbitrary formats.

The one thing that had to be dealt with was component alpha. In
addition to interpreting the presence of the NEED_COMPONENT_ALPHA
flag, we now also interprete the *absence* of this flag as a
requirement that the mask does *not* have component alpha.

Siarhei Siamashka pointed out that the first version of this commit
had a bug, in which a NEED_SOLID_MASK was accidentally not turned into
a PIXMAN_solid in the ARM NEON implementation.

Use the destination buffer directly in more cases instead of fetching.

When the destination buffer is either a8r8g8b8 or x8r8g8b8, we can use
it directly instead of fetching into a temporary buffer. When the
format is x8r8g8b8, we require the operator to not make use of
destination alpha, but when it is a8r8g8b8, there are no restrictions.

This is approximately a 5% speedup on the poppler cairo benchmark:

[ # ]  backend                         test   min(s) median(s) stddev. count

Before:
[  0]    image                      poppler    6.661    6.709   0.59%    6/6

After:
[  0]    image                      poppler    6.307    6.320   0.12%    5/6

test: Move image_endian_swap() from blitters-test.c to utils.[ch]

test: Move random number generator from blitters/scaling-test to utils.[ch]

test: In scaling-test use the crc32 from utils.c

test: Move CRC32 code from blitters-test to new files utils.[ch]

test: Rename utils.[ch] to gtk-utils.[ch]

sse2: Add a fast path for OVER 8888 x 8 x 8888

This is a small speedup on the swfdec-youtube benchmark:

Before:
[  0]    image               swfdec-youtube    5.789    5.806   0.20%    6/6

After:
[  0]    image               swfdec-youtube    5.489    5.524   0.27%    6/6

Ie., approximately 5% faster.

ARM: enabled 'neon_composite_add_8000_8000' fast path

ARM: enabled 'neon_composite_add_8_8_8' fast path

ARM: enabled 'neon_composite_add_n_8_8' fast path

ARM: enabled 'neon_composite_over_8888_8888' fast path

ARM: enabled 'neon_composite_over_8888_0565' fast path

ARM: enabled 'neon_composite_over_8888_n_8888' fast path