| /* |
| * |
| * Copyright © 2000 Keith Packard, member of The XFree86 Project, Inc. |
| * 2005 Lars Knoll & Zack Rusin, Trolltech |
| * |
| * Permission to use, copy, modify, distribute, and sell this software and its |
| * documentation for any purpose is hereby granted without fee, provided that |
| * the above copyright notice appear in all copies and that both that |
| * copyright notice and this permission notice appear in supporting |
| * documentation, and that the name of Keith Packard not be used in |
| * advertising or publicity pertaining to distribution of the software without |
| * specific, written prior permission. Keith Packard makes no |
| * representations about the suitability of this software for any purpose. It |
| * is provided "as is" without express or implied warranty. |
| * |
| * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS |
| * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND |
| * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY |
| * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN |
| * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING |
| * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS |
| * SOFTWARE. |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include <config.h> |
| #endif |
| #include "pixman-private.h" |
| |
| void |
| _pixman_gradient_walker_init (pixman_gradient_walker_t *walker, |
| gradient_t * gradient, |
| unsigned int spread) |
| { |
| walker->num_stops = gradient->n_stops; |
| walker->stops = gradient->stops; |
| walker->left_x = 0; |
| walker->right_x = 0x10000; |
| walker->stepper = 0; |
| walker->left_ag = 0; |
| walker->left_rb = 0; |
| walker->right_ag = 0; |
| walker->right_rb = 0; |
| walker->spread = spread; |
| |
| walker->need_reset = TRUE; |
| } |
| |
| void |
| _pixman_gradient_walker_reset (pixman_gradient_walker_t *walker, |
| pixman_fixed_32_32_t pos) |
| { |
| int32_t x, left_x, right_x; |
| pixman_color_t *left_c, *right_c; |
| int n, count = walker->num_stops; |
| pixman_gradient_stop_t * stops = walker->stops; |
| |
| static const pixman_color_t transparent_black = { 0, 0, 0, 0 }; |
| |
| switch (walker->spread) |
| { |
| case PIXMAN_REPEAT_NORMAL: |
| x = (int32_t)pos & 0xFFFF; |
| for (n = 0; n < count; n++) |
| if (x < stops[n].x) |
| break; |
| if (n == 0) |
| { |
| left_x = stops[count - 1].x - 0x10000; |
| left_c = &stops[count - 1].color; |
| } |
| else |
| { |
| left_x = stops[n - 1].x; |
| left_c = &stops[n - 1].color; |
| } |
| |
| if (n == count) |
| { |
| right_x = stops[0].x + 0x10000; |
| right_c = &stops[0].color; |
| } |
| else |
| { |
| right_x = stops[n].x; |
| right_c = &stops[n].color; |
| } |
| left_x += (pos - x); |
| right_x += (pos - x); |
| break; |
| |
| case PIXMAN_REPEAT_PAD: |
| for (n = 0; n < count; n++) |
| if (pos < stops[n].x) |
| break; |
| |
| if (n == 0) |
| { |
| left_x = INT32_MIN; |
| left_c = &stops[0].color; |
| } |
| else |
| { |
| left_x = stops[n - 1].x; |
| left_c = &stops[n - 1].color; |
| } |
| |
| if (n == count) |
| { |
| right_x = INT32_MAX; |
| right_c = &stops[n - 1].color; |
| } |
| else |
| { |
| right_x = stops[n].x; |
| right_c = &stops[n].color; |
| } |
| break; |
| |
| case PIXMAN_REPEAT_REFLECT: |
| x = (int32_t)pos & 0xFFFF; |
| if ((int32_t)pos & 0x10000) |
| x = 0x10000 - x; |
| for (n = 0; n < count; n++) |
| if (x < stops[n].x) |
| break; |
| |
| if (n == 0) |
| { |
| left_x = -stops[0].x; |
| left_c = &stops[0].color; |
| } |
| else |
| { |
| left_x = stops[n - 1].x; |
| left_c = &stops[n - 1].color; |
| } |
| |
| if (n == count) |
| { |
| right_x = 0x20000 - stops[n - 1].x; |
| right_c = &stops[n - 1].color; |
| } |
| else |
| { |
| right_x = stops[n].x; |
| right_c = &stops[n].color; |
| } |
| |
| if ((int32_t)pos & 0x10000) |
| { |
| pixman_color_t *tmp_c; |
| int32_t tmp_x; |
| |
| tmp_x = 0x10000 - right_x; |
| right_x = 0x10000 - left_x; |
| left_x = tmp_x; |
| |
| tmp_c = right_c; |
| right_c = left_c; |
| left_c = tmp_c; |
| |
| x = 0x10000 - x; |
| } |
| left_x += (pos - x); |
| right_x += (pos - x); |
| break; |
| |
| default: /* REPEAT_NONE */ |
| for (n = 0; n < count; n++) |
| if (pos < stops[n].x) |
| break; |
| |
| if (n == 0) |
| { |
| left_x = INT32_MIN; |
| right_x = stops[0].x; |
| left_c = right_c = (pixman_color_t*) &transparent_black; |
| } |
| else if (n == count) |
| { |
| left_x = stops[n - 1].x; |
| right_x = INT32_MAX; |
| left_c = right_c = (pixman_color_t*) &transparent_black; |
| } |
| else |
| { |
| left_x = stops[n - 1].x; |
| right_x = stops[n].x; |
| left_c = &stops[n - 1].color; |
| right_c = &stops[n].color; |
| } |
| } |
| |
| walker->left_x = left_x; |
| walker->right_x = right_x; |
| walker->left_ag = ((left_c->alpha >> 8) << 16) | (left_c->green >> 8); |
| walker->left_rb = ((left_c->red & 0xff00) << 8) | (left_c->blue >> 8); |
| walker->right_ag = ((right_c->alpha >> 8) << 16) | (right_c->green >> 8); |
| walker->right_rb = ((right_c->red & 0xff00) << 8) | (right_c->blue >> 8); |
| |
| if (walker->left_x == walker->right_x || |
| ( walker->left_ag == walker->right_ag && |
| walker->left_rb == walker->right_rb ) ) |
| { |
| walker->stepper = 0; |
| } |
| else |
| { |
| int32_t width = right_x - left_x; |
| walker->stepper = ((1 << 24) + width / 2) / width; |
| } |
| |
| walker->need_reset = FALSE; |
| } |
| |
| #define PIXMAN_GRADIENT_WALKER_NEED_RESET(w, x) \ |
| ( (w)->need_reset || (x) < (w)->left_x || (x) >= (w)->right_x) |
| |
| |
| /* the following assumes that PIXMAN_GRADIENT_WALKER_NEED_RESET(w,x) is FALSE */ |
| uint32_t |
| _pixman_gradient_walker_pixel (pixman_gradient_walker_t *walker, |
| pixman_fixed_32_32_t x) |
| { |
| int dist, idist; |
| uint32_t t1, t2, a, color; |
| |
| if (PIXMAN_GRADIENT_WALKER_NEED_RESET (walker, x)) |
| _pixman_gradient_walker_reset (walker, x); |
| |
| dist = ((int)(x - walker->left_x) * walker->stepper) >> 16; |
| idist = 256 - dist; |
| |
| /* combined INTERPOLATE and premultiply */ |
| t1 = walker->left_rb * idist + walker->right_rb * dist; |
| t1 = (t1 >> 8) & 0xff00ff; |
| |
| t2 = walker->left_ag * idist + walker->right_ag * dist; |
| t2 &= 0xff00ff00; |
| |
| color = t2 & 0xff000000; |
| a = t2 >> 24; |
| |
| t1 = t1 * a + 0x800080; |
| t1 = (t1 + ((t1 >> 8) & 0xff00ff)) >> 8; |
| |
| t2 = (t2 >> 8) * a + 0x800080; |
| t2 = (t2 + ((t2 >> 8) & 0xff00ff)); |
| |
| return (color | (t1 & 0xff00ff) | (t2 & 0xff00)); |
| } |
| |