The Tor Browser / annotate

gfx/cairo/pixman-8888-over-565.patch@97036ab72558 (annotated)

gfx/cairo/pixman-8888-over-565.patch

Tue, 06 Jan 2015 21:39:09 +0100

author
Michael Schloh von Bennewitz <michael@schloh.com>
date
Tue, 06 Jan 2015 21:39:09 +0100
branch
TOR_BUG_9701
changeset 8
97036ab72558
permissions
-rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

michael@0 1 changeset: 96613:3e003f0b8026
michael@0 2 tag: 2pass
michael@0 3 tag: qbase
michael@0 4 tag: qtip
michael@0 5 tag: tip
michael@0 6 user: Jeff Muizelaar <jmuizelaar@mozilla.com>
michael@0 7 date: Thu May 17 19:23:53 2012 -0400
michael@0 8 summary: Bug 757878. Add a fast path for 8888_over_565 with NEON. r=bgirard,joe
michael@0 9
michael@0 10 diff --git a/gfx/cairo/libpixman/src/pixman-arm-common.h b/gfx/cairo/libpixman/src/pixman-arm-common.h
michael@0 11 --- a/gfx/cairo/libpixman/src/pixman-arm-common.h
michael@0 12 +++ b/gfx/cairo/libpixman/src/pixman-arm-common.h
michael@0 13 @@ -355,26 +355,26 @@ scaled_bilinear_scanline_##cputype##_##n
michael@0 14 if ((flags & SKIP_ZERO_SRC) && zero_src) \
michael@0 15 return; \
michael@0 16 pixman_scaled_bilinear_scanline_##name##_##op##_asm_##cputype ( \
michael@0 17 dst, src_top, src_bottom, wt, wb, vx, unit_x, w); \
michael@0 18 } \
michael@0 19 \
michael@0 20 FAST_BILINEAR_MAINLOOP_COMMON (cputype##_##name##_cover_##op, \
michael@0 21 scaled_bilinear_scanline_##cputype##_##name##_##op, \
michael@0 22 - src_type, uint32_t, dst_type, COVER, FLAG_NONE) \
michael@0 23 + NULL, src_type, uint32_t, dst_type, COVER, FLAG_NONE) \
michael@0 24 FAST_BILINEAR_MAINLOOP_COMMON (cputype##_##name##_none_##op, \
michael@0 25 scaled_bilinear_scanline_##cputype##_##name##_##op, \
michael@0 26 - src_type, uint32_t, dst_type, NONE, FLAG_NONE) \
michael@0 27 + NULL, src_type, uint32_t, dst_type, NONE, FLAG_NONE) \
michael@0 28 FAST_BILINEAR_MAINLOOP_COMMON (cputype##_##name##_pad_##op, \
michael@0 29 scaled_bilinear_scanline_##cputype##_##name##_##op, \
michael@0 30 - src_type, uint32_t, dst_type, PAD, FLAG_NONE) \
michael@0 31 + NULL, src_type, uint32_t, dst_type, PAD, FLAG_NONE) \
michael@0 32 FAST_BILINEAR_MAINLOOP_COMMON (cputype##_##name##_normal_##op, \
michael@0 33 scaled_bilinear_scanline_##cputype##_##name##_##op, \
michael@0 34 - src_type, uint32_t, dst_type, NORMAL, \
michael@0 35 + NULL, src_type, uint32_t, dst_type, NORMAL, \
michael@0 36 FLAG_NONE)
michael@0 37
michael@0 38
michael@0 39 #define PIXMAN_ARM_BIND_SCALED_BILINEAR_SRC_A8_DST(flags, cputype, name, op, \
michael@0 40 src_type, dst_type) \
michael@0 41 void \
michael@0 42 pixman_scaled_bilinear_scanline_##name##_##op##_asm_##cputype ( \
michael@0 43 dst_type * dst, \
michael@0 44 @@ -404,25 +404,25 @@ scaled_bilinear_scanline_##cputype##_##n
michael@0 45 if ((flags & SKIP_ZERO_SRC) && zero_src) \
michael@0 46 return; \
michael@0 47 pixman_scaled_bilinear_scanline_##name##_##op##_asm_##cputype ( \
michael@0 48 dst, mask, src_top, src_bottom, wt, wb, vx, unit_x, w); \
michael@0 49 } \
michael@0 50 \
michael@0 51 FAST_BILINEAR_MAINLOOP_COMMON (cputype##_##name##_cover_##op, \
michael@0 52 scaled_bilinear_scanline_##cputype##_##name##_##op, \
michael@0 53 - src_type, uint8_t, dst_type, COVER, \
michael@0 54 + NULL, src_type, uint8_t, dst_type, COVER, \
michael@0 55 FLAG_HAVE_NON_SOLID_MASK) \
michael@0 56 FAST_BILINEAR_MAINLOOP_COMMON (cputype##_##name##_none_##op, \
michael@0 57 scaled_bilinear_scanline_##cputype##_##name##_##op, \
michael@0 58 - src_type, uint8_t, dst_type, NONE, \
michael@0 59 + NULL, src_type, uint8_t, dst_type, NONE, \
michael@0 60 FLAG_HAVE_NON_SOLID_MASK) \
michael@0 61 FAST_BILINEAR_MAINLOOP_COMMON (cputype##_##name##_pad_##op, \
michael@0 62 scaled_bilinear_scanline_##cputype##_##name##_##op, \
michael@0 63 - src_type, uint8_t, dst_type, PAD, \
michael@0 64 + NULL, src_type, uint8_t, dst_type, PAD, \
michael@0 65 FLAG_HAVE_NON_SOLID_MASK) \
michael@0 66 FAST_BILINEAR_MAINLOOP_COMMON (cputype##_##name##_normal_##op, \
michael@0 67 scaled_bilinear_scanline_##cputype##_##name##_##op, \
michael@0 68 - src_type, uint8_t, dst_type, NORMAL, \
michael@0 69 + NULL, src_type, uint8_t, dst_type, NORMAL, \
michael@0 70 FLAG_HAVE_NON_SOLID_MASK)
michael@0 71
michael@0 72
michael@0 73 #endif
michael@0 74 diff --git a/gfx/cairo/libpixman/src/pixman-arm-neon.c b/gfx/cairo/libpixman/src/pixman-arm-neon.c
michael@0 75 --- a/gfx/cairo/libpixman/src/pixman-arm-neon.c
michael@0 76 +++ b/gfx/cairo/libpixman/src/pixman-arm-neon.c
michael@0 77 @@ -140,16 +140,33 @@ PIXMAN_ARM_BIND_SCALED_BILINEAR_SRC_DST
michael@0 78 PIXMAN_ARM_BIND_SCALED_BILINEAR_SRC_DST (0, neon, 8888_0565, SRC,
michael@0 79 uint32_t, uint16_t)
michael@0 80 PIXMAN_ARM_BIND_SCALED_BILINEAR_SRC_DST (0, neon, 0565_x888, SRC,
michael@0 81 uint16_t, uint32_t)
michael@0 82 PIXMAN_ARM_BIND_SCALED_BILINEAR_SRC_DST (0, neon, 0565_0565, SRC,
michael@0 83 uint16_t, uint16_t)
michael@0 84 PIXMAN_ARM_BIND_SCALED_BILINEAR_SRC_DST (SKIP_ZERO_SRC, neon, 8888_8888, OVER,
michael@0 85 uint32_t, uint32_t)
michael@0 86 +static force_inline void
michael@0 87 +pixman_scaled_bilinear_scanline_8888_8888_SRC (
michael@0 88 + uint32_t * dst,
michael@0 89 + const uint32_t * mask,
michael@0 90 + const uint32_t * src_top,
michael@0 91 + const uint32_t * src_bottom,
michael@0 92 + int32_t w,
michael@0 93 + int wt,
michael@0 94 + int wb,
michael@0 95 + pixman_fixed_t vx,
michael@0 96 + pixman_fixed_t unit_x,
michael@0 97 + pixman_fixed_t max_vx,
michael@0 98 + pixman_bool_t zero_src)
michael@0 99 +{
michael@0 100 + pixman_scaled_bilinear_scanline_8888_8888_SRC_asm_neon (dst, src_top, src_bottom, wt, wb, vx, unit_x, w);
michael@0 101 +}
michael@0 102 +
michael@0 103 PIXMAN_ARM_BIND_SCALED_BILINEAR_SRC_DST (SKIP_ZERO_SRC, neon, 8888_8888, ADD,
michael@0 104 uint32_t, uint32_t)
michael@0 105
michael@0 106 PIXMAN_ARM_BIND_SCALED_BILINEAR_SRC_A8_DST (0, neon, 8888_8_8888, SRC,
michael@0 107 uint32_t, uint32_t)
michael@0 108 PIXMAN_ARM_BIND_SCALED_BILINEAR_SRC_A8_DST (0, neon, 8888_8_0565, SRC,
michael@0 109 uint32_t, uint16_t)
michael@0 110 PIXMAN_ARM_BIND_SCALED_BILINEAR_SRC_A8_DST (0, neon, 0565_8_x888, SRC,
michael@0 111 @@ -261,16 +278,38 @@ pixman_blt_neon (uint32_t *src_bits,
michael@0 112 (uint32_t *)(((char *) src_bits) +
michael@0 113 src_y * src_stride * 4 + src_x * 4), src_stride);
michael@0 114 return TRUE;
michael@0 115 default:
michael@0 116 return FALSE;
michael@0 117 }
michael@0 118 }
michael@0 119
michael@0 120 +static inline void op_bilinear_over_8888_0565(uint16_t *dst, const uint32_t *mask, const uint32_t *src, int width)
michael@0 121 +{
michael@0 122 + pixman_composite_over_8888_0565_asm_neon (width, 1, dst, 0, src, 0);
michael@0 123 +}
michael@0 124 +
michael@0 125 +FAST_BILINEAR_MAINLOOP_COMMON (neon_8888_0565_cover_OVER,
michael@0 126 + pixman_scaled_bilinear_scanline_8888_8888_SRC, op_bilinear_over_8888_0565,
michael@0 127 + uint32_t, uint32_t, uint16_t,
michael@0 128 + COVER, FLAG_NONE)
michael@0 129 +FAST_BILINEAR_MAINLOOP_COMMON (neon_8888_0565_pad_OVER,
michael@0 130 + pixman_scaled_bilinear_scanline_8888_8888_SRC, op_bilinear_over_8888_0565,
michael@0 131 + uint32_t, uint32_t, uint16_t,
michael@0 132 + PAD, FLAG_NONE)
michael@0 133 +FAST_BILINEAR_MAINLOOP_COMMON (neon_8888_0565_none_OVER,
michael@0 134 + pixman_scaled_bilinear_scanline_8888_8888_SRC, op_bilinear_over_8888_0565,
michael@0 135 + uint32_t, uint32_t, uint16_t,
michael@0 136 + NONE, FLAG_NONE)
michael@0 137 +FAST_BILINEAR_MAINLOOP_COMMON (neon_8888_0565_normal_OVER,
michael@0 138 + pixman_scaled_bilinear_scanline_8888_8888_SRC, op_bilinear_over_8888_0565,
michael@0 139 + uint32_t, uint32_t, uint16_t,
michael@0 140 + NORMAL, FLAG_NONE)
michael@0 141 +
michael@0 142 static const pixman_fast_path_t arm_neon_fast_paths[] =
michael@0 143 {
michael@0 144 PIXMAN_STD_FAST_PATH (SRC, r5g6b5, null, r5g6b5, neon_composite_src_0565_0565),
michael@0 145 PIXMAN_STD_FAST_PATH (SRC, b5g6r5, null, b5g6r5, neon_composite_src_0565_0565),
michael@0 146 PIXMAN_STD_FAST_PATH (SRC, a8r8g8b8, null, r5g6b5, neon_composite_src_8888_0565),
michael@0 147 PIXMAN_STD_FAST_PATH (SRC, x8r8g8b8, null, r5g6b5, neon_composite_src_8888_0565),
michael@0 148 PIXMAN_STD_FAST_PATH (SRC, a8b8g8r8, null, b5g6r5, neon_composite_src_8888_0565),
michael@0 149 PIXMAN_STD_FAST_PATH (SRC, x8b8g8r8, null, b5g6r5, neon_composite_src_8888_0565),
michael@0 150 @@ -414,16 +453,18 @@ static const pixman_fast_path_t arm_neon
michael@0 151 SIMPLE_BILINEAR_A8_MASK_FAST_PATH (SRC, r5g6b5, r5g6b5, neon_0565_8_0565),
michael@0 152
michael@0 153 SIMPLE_BILINEAR_A8_MASK_FAST_PATH (OVER, a8r8g8b8, a8r8g8b8, neon_8888_8_8888),
michael@0 154 SIMPLE_BILINEAR_A8_MASK_FAST_PATH (OVER, a8r8g8b8, x8r8g8b8, neon_8888_8_8888),
michael@0 155
michael@0 156 SIMPLE_BILINEAR_A8_MASK_FAST_PATH (ADD, a8r8g8b8, a8r8g8b8, neon_8888_8_8888),
michael@0 157 SIMPLE_BILINEAR_A8_MASK_FAST_PATH (ADD, a8r8g8b8, x8r8g8b8, neon_8888_8_8888),
michael@0 158
michael@0 159 + SIMPLE_BILINEAR_FAST_PATH (OVER, a8r8g8b8, r5g6b5, neon_8888_0565),
michael@0 160 +
michael@0 161 { PIXMAN_OP_NONE },
michael@0 162 };
michael@0 163
michael@0 164 static pixman_bool_t
michael@0 165 arm_neon_blt (pixman_implementation_t *imp,
michael@0 166 uint32_t * src_bits,
michael@0 167 uint32_t * dst_bits,
michael@0 168 int src_stride,
michael@0 169 diff --git a/gfx/cairo/libpixman/src/pixman-fast-path.c b/gfx/cairo/libpixman/src/pixman-fast-path.c
michael@0 170 --- a/gfx/cairo/libpixman/src/pixman-fast-path.c
michael@0 171 +++ b/gfx/cairo/libpixman/src/pixman-fast-path.c
michael@0 172 @@ -1356,63 +1356,63 @@ scaled_bilinear_scanline_565_565_SRC (ui
michael@0 173 vx += unit_x;
michael@0 174 *dst++ = d;
michael@0 175 }
michael@0 176 }
michael@0 177
michael@0 178 #endif
michael@0 179
michael@0 180 FAST_BILINEAR_MAINLOOP_COMMON (565_565_cover_SRC,
michael@0 181 - scaled_bilinear_scanline_565_565_SRC,
michael@0 182 + scaled_bilinear_scanline_565_565_SRC, NULL,
michael@0 183 uint16_t, uint32_t, uint16_t,
michael@0 184 COVER, FLAG_NONE)
michael@0 185 FAST_BILINEAR_MAINLOOP_COMMON (565_565_pad_SRC,
michael@0 186 - scaled_bilinear_scanline_565_565_SRC,
michael@0 187 + scaled_bilinear_scanline_565_565_SRC, NULL,
michael@0 188 uint16_t, uint32_t, uint16_t,
michael@0 189 PAD, FLAG_NONE)
michael@0 190 FAST_BILINEAR_MAINLOOP_COMMON (565_565_none_SRC,
michael@0 191 - scaled_bilinear_scanline_565_565_SRC,
michael@0 192 + scaled_bilinear_scanline_565_565_SRC, NULL,
michael@0 193 uint16_t, uint32_t, uint16_t,
michael@0 194 NONE, FLAG_NONE)
michael@0 195 FAST_BILINEAR_MAINLOOP_COMMON (565_565_normal_SRC,
michael@0 196 - scaled_bilinear_scanline_565_565_SRC,
michael@0 197 + scaled_bilinear_scanline_565_565_SRC, NULL,
michael@0 198 uint16_t, uint32_t, uint16_t,
michael@0 199 NORMAL, FLAG_NONE)
michael@0 200
michael@0 201 FAST_BILINEAR_MAINLOOP_COMMON (8888_565_cover_OVER,
michael@0 202 - scaled_bilinear_scanline_8888_565_OVER,
michael@0 203 + scaled_bilinear_scanline_8888_565_OVER, NULL,
michael@0 204 uint32_t, uint32_t, uint16_t,
michael@0 205 COVER, FLAG_NONE)
michael@0 206 FAST_BILINEAR_MAINLOOP_COMMON (8888_565_pad_OVER,
michael@0 207 - scaled_bilinear_scanline_8888_565_OVER,
michael@0 208 + scaled_bilinear_scanline_8888_565_OVER, NULL,
michael@0 209 uint32_t, uint32_t, uint16_t,
michael@0 210 PAD, FLAG_NONE)
michael@0 211 FAST_BILINEAR_MAINLOOP_COMMON (8888_565_none_OVER,
michael@0 212 - scaled_bilinear_scanline_8888_565_OVER,
michael@0 213 + scaled_bilinear_scanline_8888_565_OVER, NULL,
michael@0 214 uint32_t, uint32_t, uint16_t,
michael@0 215 NONE, FLAG_NONE)
michael@0 216 FAST_BILINEAR_MAINLOOP_COMMON (8888_565_normal_OVER,
michael@0 217 - scaled_bilinear_scanline_8888_565_OVER,
michael@0 218 + scaled_bilinear_scanline_8888_565_OVER, NULL,
michael@0 219 uint32_t, uint32_t, uint16_t,
michael@0 220 NORMAL, FLAG_NONE)
michael@0 221
michael@0 222 FAST_BILINEAR_MAINLOOP_COMMON (8888_8888_cover_OVER,
michael@0 223 - scaled_bilinear_scanline_8888_8888_OVER,
michael@0 224 + scaled_bilinear_scanline_8888_8888_OVER, NULL,
michael@0 225 uint32_t, uint32_t, uint32_t,
michael@0 226 COVER, FLAG_NONE)
michael@0 227 FAST_BILINEAR_MAINLOOP_COMMON (8888_8888_pad_OVER,
michael@0 228 - scaled_bilinear_scanline_8888_8888_OVER,
michael@0 229 + scaled_bilinear_scanline_8888_8888_OVER, NULL,
michael@0 230 uint32_t, uint32_t, uint32_t,
michael@0 231 PAD, FLAG_NONE)
michael@0 232 FAST_BILINEAR_MAINLOOP_COMMON (8888_8888_none_OVER,
michael@0 233 - scaled_bilinear_scanline_8888_8888_OVER,
michael@0 234 + scaled_bilinear_scanline_8888_8888_OVER, NULL,
michael@0 235 uint32_t, uint32_t, uint32_t,
michael@0 236 NONE, FLAG_NONE)
michael@0 237 FAST_BILINEAR_MAINLOOP_COMMON (8888_8888_normal_OVER,
michael@0 238 - scaled_bilinear_scanline_8888_8888_OVER,
michael@0 239 + scaled_bilinear_scanline_8888_8888_OVER, NULL,
michael@0 240 uint32_t, uint32_t, uint32_t,
michael@0 241 NORMAL, FLAG_NONE)
michael@0 242
michael@0 243 #define REPEAT_MIN_WIDTH 32
michael@0 244
michael@0 245 static void
michael@0 246 fast_composite_tiled_repeat (pixman_implementation_t *imp,
michael@0 247 pixman_composite_info_t *info)
michael@0 248 diff --git a/gfx/cairo/libpixman/src/pixman-inlines.h b/gfx/cairo/libpixman/src/pixman-inlines.h
michael@0 249 --- a/gfx/cairo/libpixman/src/pixman-inlines.h
michael@0 250 +++ b/gfx/cairo/libpixman/src/pixman-inlines.h
michael@0 251 @@ -816,18 +816,48 @@ bilinear_pad_repeat_get_scanline_bounds
michael@0 252 *
michael@0 253 * Note: normally the sum of 'weight_top' and 'weight_bottom' is equal to 256,
michael@0 254 * but sometimes it may be less than that for NONE repeat when handling
michael@0 255 * fuzzy antialiased top or bottom image edges. Also both top and
michael@0 256 * bottom weight variables are guaranteed to have value in 0-255
michael@0 257 * range and can fit into unsigned byte or be used with 8-bit SIMD
michael@0 258 * multiplication instructions.
michael@0 259 */
michael@0 260 -#define FAST_BILINEAR_MAINLOOP_INT(scale_func_name, scanline_func, src_type_t, mask_type_t, \
michael@0 261 - dst_type_t, repeat_mode, flags) \
michael@0 262 +
michael@0 263 +/* Replace a single "scanline_func" with "fetch_func" & "op_func" to allow optional
michael@0 264 + * two stage processing (bilinear fetch to a temp buffer, followed by unscaled
michael@0 265 + * combine), "op_func" may be NULL, in this case we keep old behavior.
michael@0 266 + * This is ugly and gcc issues some warnings, but works.
michael@0 267 + *
michael@0 268 + * An advice: clang has much better error reporting than gcc for deeply nested macros.
michael@0 269 + */
michael@0 270 +
michael@0 271 +#define scanline_func(dst_type_t, mask_type_t, src_type_t, fetch_func, op_func, dst, \
michael@0 272 + scanline_buf, mask, src_top, src_bottom, width, \
michael@0 273 + weight_top, weight_bottom, vx, unit_x, max_vx, zero_src) \
michael@0 274 + do { \
michael@0 275 + if (op_func != NULL) \
michael@0 276 + { \
michael@0 277 + fetch_func ((void *)scanline_buf, (mask), (src_top), (src_bottom), (width), \
michael@0 278 + (weight_top), (weight_bottom), (vx), (unit_x), (max_vx), (zero_src)); \
michael@0 279 + ((void (*)(dst_type_t *, const mask_type_t *, const src_type_t *, int)) op_func)\
michael@0 280 + ((dst), (mask), (src_type_t *)scanline_buf, (width)); \
michael@0 281 + } \
michael@0 282 + else \
michael@0 283 + { \
michael@0 284 + fetch_func ((void*)(dst), (mask), (src_top), (src_bottom), (width), (weight_top), \
michael@0 285 + (weight_bottom), (vx), (unit_x), (max_vx), (zero_src)); \
michael@0 286 + } \
michael@0 287 + } while (0)
michael@0 288 +
michael@0 289 +
michael@0 290 +#define SCANLINE_BUFFER_LENGTH 3072
michael@0 291 +
michael@0 292 +#define FAST_BILINEAR_MAINLOOP_INT(scale_func_name, fetch_func, op_func, src_type_t, \
michael@0 293 + mask_type_t, dst_type_t, repeat_mode, flags) \
michael@0 294 static void \
michael@0 295 fast_composite_scaled_bilinear ## scale_func_name (pixman_implementation_t *imp, \
michael@0 296 pixman_composite_info_t *info) \
michael@0 297 { \
michael@0 298 PIXMAN_COMPOSITE_ARGS (info); \
michael@0 299 dst_type_t *dst_line; \
michael@0 300 mask_type_t *mask_line; \
michael@0 301 src_type_t *src_first_line; \
michael@0 302 @@ -842,16 +872,19 @@ fast_composite_scaled_bilinear ## scale_
michael@0 303 mask_type_t solid_mask; \
michael@0 304 const mask_type_t *mask = &solid_mask; \
michael@0 305 int src_stride, mask_stride, dst_stride; \
michael@0 306 \
michael@0 307 int src_width; \
michael@0 308 pixman_fixed_t src_width_fixed; \
michael@0 309 int max_x; \
michael@0 310 pixman_bool_t need_src_extension; \
michael@0 311 + \
michael@0 312 + uint64_t stack_scanline_buffer[SCANLINE_BUFFER_LENGTH]; \
michael@0 313 + uint8_t *scanline_buffer = (uint8_t *) stack_scanline_buffer; \
michael@0 314 \
michael@0 315 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, dst_type_t, dst_stride, dst_line, 1); \
michael@0 316 if (flags & FLAG_HAVE_SOLID_MASK) \
michael@0 317 { \
michael@0 318 solid_mask = _pixman_image_get_solid (imp, mask_image, dest_image->bits.format); \
michael@0 319 mask_stride = 0; \
michael@0 320 } \
michael@0 321 else if (flags & FLAG_HAVE_NON_SOLID_MASK) \
michael@0 322 @@ -914,16 +947,24 @@ fast_composite_scaled_bilinear ## scale_
michael@0 323 else \
michael@0 324 { \
michael@0 325 src_width = src_image->bits.width; \
michael@0 326 need_src_extension = FALSE; \
michael@0 327 } \
michael@0 328 \
michael@0 329 src_width_fixed = pixman_int_to_fixed (src_width); \
michael@0 330 } \
michael@0 331 + \
michael@0 332 + if (op_func != NULL && width * sizeof(src_type_t) > sizeof(stack_scanline_buffer)) \
michael@0 333 + { \
michael@0 334 + scanline_buffer = pixman_malloc_ab (width, sizeof(src_type_t)); \
michael@0 335 + \
michael@0 336 + if (!scanline_buffer) \
michael@0 337 + return; \
michael@0 338 + } \
michael@0 339 \
michael@0 340 while (--height >= 0) \
michael@0 341 { \
michael@0 342 int weight1, weight2; \
michael@0 343 dst = dst_line; \
michael@0 344 dst_line += dst_stride; \
michael@0 345 vx = v.vector[0]; \
michael@0 346 if (flags & FLAG_HAVE_NON_SOLID_MASK) \
michael@0 347 @@ -956,36 +997,39 @@ fast_composite_scaled_bilinear ## scale_
michael@0 348 repeat (PIXMAN_REPEAT_PAD, &y2, src_image->bits.height); \
michael@0 349 src1 = src_first_line + src_stride * y1; \
michael@0 350 src2 = src_first_line + src_stride * y2; \
michael@0 351 \
michael@0 352 if (left_pad > 0) \
michael@0 353 { \
michael@0 354 buf1[0] = buf1[1] = src1[0]; \
michael@0 355 buf2[0] = buf2[1] = src2[0]; \
michael@0 356 - scanline_func (dst, mask, \
michael@0 357 - buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, FALSE); \
michael@0 358 + scanline_func (dst_type_t, mask_type_t, src_type_t, fetch_func, op_func, dst, \
michael@0 359 + scanline_buffer, mask, buf1, buf2, left_pad, weight1, weight2, \
michael@0 360 + 0, 0, 0, FALSE); \
michael@0 361 dst += left_pad; \
michael@0 362 if (flags & FLAG_HAVE_NON_SOLID_MASK) \
michael@0 363 mask += left_pad; \
michael@0 364 } \
michael@0 365 if (width > 0) \
michael@0 366 { \
michael@0 367 - scanline_func (dst, mask, \
michael@0 368 - src1, src2, width, weight1, weight2, vx, unit_x, 0, FALSE); \
michael@0 369 + scanline_func (dst_type_t, mask_type_t, src_type_t, fetch_func, op_func, dst, \
michael@0 370 + scanline_buffer, mask, src1, src2, width, weight1, weight2, \
michael@0 371 + vx, unit_x, 0, FALSE); \
michael@0 372 dst += width; \
michael@0 373 if (flags & FLAG_HAVE_NON_SOLID_MASK) \
michael@0 374 mask += width; \
michael@0 375 } \
michael@0 376 if (right_pad > 0) \
michael@0 377 { \
michael@0 378 buf1[0] = buf1[1] = src1[src_image->bits.width - 1]; \
michael@0 379 buf2[0] = buf2[1] = src2[src_image->bits.width - 1]; \
michael@0 380 - scanline_func (dst, mask, \
michael@0 381 - buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, FALSE); \
michael@0 382 + scanline_func (dst_type_t, mask_type_t, src_type_t, fetch_func, op_func, dst, \
michael@0 383 + scanline_buffer, mask, buf1, buf2, right_pad, weight1, weight2, \
michael@0 384 + 0, 0, 0, FALSE); \
michael@0 385 } \
michael@0 386 } \
michael@0 387 else if (PIXMAN_REPEAT_ ## repeat_mode == PIXMAN_REPEAT_NONE) \
michael@0 388 { \
michael@0 389 src_type_t *src1, *src2; \
michael@0 390 src_type_t buf1[2]; \
michael@0 391 src_type_t buf2[2]; \
michael@0 392 /* handle top/bottom zero padding by just setting weights to 0 if needed */ \
michael@0 393 @@ -1011,64 +1055,67 @@ fast_composite_scaled_bilinear ## scale_
michael@0 394 } \
michael@0 395 src1 = src_first_line + src_stride * y1; \
michael@0 396 src2 = src_first_line + src_stride * y2; \
michael@0 397 \
michael@0 398 if (left_pad > 0) \
michael@0 399 { \
michael@0 400 buf1[0] = buf1[1] = 0; \
michael@0 401 buf2[0] = buf2[1] = 0; \
michael@0 402 - scanline_func (dst, mask, \
michael@0 403 - buf1, buf2, left_pad, weight1, weight2, 0, 0, 0, TRUE); \
michael@0 404 + scanline_func (dst_type_t, mask_type_t, src_type_t, fetch_func, op_func, dst, \
michael@0 405 + scanline_buffer, mask, buf1, buf2, left_pad, weight1, weight2, \
michael@0 406 + 0, 0, 0, TRUE); \
michael@0 407 dst += left_pad; \
michael@0 408 if (flags & FLAG_HAVE_NON_SOLID_MASK) \
michael@0 409 mask += left_pad; \
michael@0 410 } \
michael@0 411 if (left_tz > 0) \
michael@0 412 { \
michael@0 413 buf1[0] = 0; \
michael@0 414 buf1[1] = src1[0]; \
michael@0 415 buf2[0] = 0; \
michael@0 416 buf2[1] = src2[0]; \
michael@0 417 - scanline_func (dst, mask, \
michael@0 418 - buf1, buf2, left_tz, weight1, weight2, \
michael@0 419 + scanline_func (dst_type_t, mask_type_t, src_type_t, fetch_func, op_func, dst, \
michael@0 420 + scanline_buffer, mask, buf1, buf2, left_tz, weight1, weight2, \
michael@0 421 pixman_fixed_frac (vx), unit_x, 0, FALSE); \
michael@0 422 dst += left_tz; \
michael@0 423 if (flags & FLAG_HAVE_NON_SOLID_MASK) \
michael@0 424 mask += left_tz; \
michael@0 425 vx += left_tz * unit_x; \
michael@0 426 } \
michael@0 427 if (width > 0) \
michael@0 428 { \
michael@0 429 - scanline_func (dst, mask, \
michael@0 430 - src1, src2, width, weight1, weight2, vx, unit_x, 0, FALSE); \
michael@0 431 + scanline_func (dst_type_t, mask_type_t, src_type_t, fetch_func, op_func, dst, \
michael@0 432 + scanline_buffer, mask, src1, src2, width, weight1, weight2, \
michael@0 433 + vx, unit_x, 0, FALSE); \
michael@0 434 dst += width; \
michael@0 435 if (flags & FLAG_HAVE_NON_SOLID_MASK) \
michael@0 436 mask += width; \
michael@0 437 vx += width * unit_x; \
michael@0 438 } \
michael@0 439 if (right_tz > 0) \
michael@0 440 { \
michael@0 441 buf1[0] = src1[src_image->bits.width - 1]; \
michael@0 442 buf1[1] = 0; \
michael@0 443 buf2[0] = src2[src_image->bits.width - 1]; \
michael@0 444 buf2[1] = 0; \
michael@0 445 - scanline_func (dst, mask, \
michael@0 446 - buf1, buf2, right_tz, weight1, weight2, \
michael@0 447 + scanline_func (dst_type_t, mask_type_t, src_type_t, fetch_func, op_func, dst, \
michael@0 448 + scanline_buffer, mask, buf1, buf2, right_tz, weight1, weight2, \
michael@0 449 pixman_fixed_frac (vx), unit_x, 0, FALSE); \
michael@0 450 dst += right_tz; \
michael@0 451 if (flags & FLAG_HAVE_NON_SOLID_MASK) \
michael@0 452 mask += right_tz; \
michael@0 453 } \
michael@0 454 if (right_pad > 0) \
michael@0 455 { \
michael@0 456 buf1[0] = buf1[1] = 0; \
michael@0 457 buf2[0] = buf2[1] = 0; \
michael@0 458 - scanline_func (dst, mask, \
michael@0 459 - buf1, buf2, right_pad, weight1, weight2, 0, 0, 0, TRUE); \
michael@0 460 + scanline_func (dst_type_t, mask_type_t, src_type_t, fetch_func, op_func, dst, \
michael@0 461 + scanline_buffer, mask, buf1, buf2, right_pad, weight1, weight2, \
michael@0 462 + 0, 0, 0, TRUE); \
michael@0 463 } \
michael@0 464 } \
michael@0 465 else if (PIXMAN_REPEAT_ ## repeat_mode == PIXMAN_REPEAT_NORMAL) \
michael@0 466 { \
michael@0 467 int32_t num_pixels; \
michael@0 468 int32_t width_remain; \
michael@0 469 src_type_t * src_line_top; \
michael@0 470 src_type_t * src_line_bottom; \
michael@0 471 @@ -1120,17 +1167,18 @@ fast_composite_scaled_bilinear ## scale_
michael@0 472 * vx is in range [0, src_width_fixed - pixman_fixed_e] \
michael@0 473 * So we are safe from overflow. \
michael@0 474 */ \
michael@0 475 num_pixels = ((src_width_fixed - vx - pixman_fixed_e) / unit_x) + 1; \
michael@0 476 \
michael@0 477 if (num_pixels > width_remain) \
michael@0 478 num_pixels = width_remain; \
michael@0 479 \
michael@0 480 - scanline_func (dst, mask, buf1, buf2, num_pixels, \
michael@0 481 + scanline_func (dst_type_t, mask_type_t, src_type_t, fetch_func, op_func, \
michael@0 482 + dst, scanline_buffer, mask, buf1, buf2, num_pixels, \
michael@0 483 weight1, weight2, pixman_fixed_frac(vx), \
michael@0 484 unit_x, src_width_fixed, FALSE); \
michael@0 485 \
michael@0 486 width_remain -= num_pixels; \
michael@0 487 vx += num_pixels * unit_x; \
michael@0 488 dst += num_pixels; \
michael@0 489 \
michael@0 490 if (flags & FLAG_HAVE_NON_SOLID_MASK) \
michael@0 491 @@ -1149,41 +1197,47 @@ fast_composite_scaled_bilinear ## scale_
michael@0 492 * So we are safe from overflow here. \
michael@0 493 */ \
michael@0 494 num_pixels = ((src_width_fixed - pixman_fixed_1 - vx - pixman_fixed_e) \
michael@0 495 / unit_x) + 1; \
michael@0 496 \
michael@0 497 if (num_pixels > width_remain) \
michael@0 498 num_pixels = width_remain; \
michael@0 499 \
michael@0 500 - scanline_func (dst, mask, src_line_top, src_line_bottom, num_pixels, \
michael@0 501 - weight1, weight2, vx, unit_x, src_width_fixed, FALSE); \
michael@0 502 + scanline_func (dst_type_t, mask_type_t, src_type_t, fetch_func, op_func, \
michael@0 503 + dst, scanline_buffer, mask, src_line_top, src_line_bottom, \
michael@0 504 + num_pixels, weight1, weight2, vx, unit_x, src_width_fixed, \
michael@0 505 + FALSE); \
michael@0 506 \
michael@0 507 width_remain -= num_pixels; \
michael@0 508 vx += num_pixels * unit_x; \
michael@0 509 dst += num_pixels; \
michael@0 510 \
michael@0 511 if (flags & FLAG_HAVE_NON_SOLID_MASK) \
michael@0 512 mask += num_pixels; \
michael@0 513 } \
michael@0 514 } \
michael@0 515 } \
michael@0 516 else \
michael@0 517 { \
michael@0 518 - scanline_func (dst, mask, src_first_line + src_stride * y1, \
michael@0 519 + scanline_func (dst_type_t, mask_type_t, src_type_t, fetch_func, op_func, dst, \
michael@0 520 + scanline_buffer, mask, \
michael@0 521 + src_first_line + src_stride * y1, \
michael@0 522 src_first_line + src_stride * y2, width, \
michael@0 523 weight1, weight2, vx, unit_x, max_vx, FALSE); \
michael@0 524 } \
michael@0 525 } \
michael@0 526 + if (scanline_buffer != (uint8_t *) stack_scanline_buffer) \
michael@0 527 + free (scanline_buffer); \
michael@0 528 }
michael@0 529
michael@0 530 /* A workaround for old sun studio, see: https://bugs.freedesktop.org/show_bug.cgi?id=32764 */
michael@0 531 -#define FAST_BILINEAR_MAINLOOP_COMMON(scale_func_name, scanline_func, src_type_t, mask_type_t, \
michael@0 532 +#define FAST_BILINEAR_MAINLOOP_COMMON(scale_func_name, fetch_func, op_func, src_type_t, mask_type_t,\
michael@0 533 dst_type_t, repeat_mode, flags) \
michael@0 534 - FAST_BILINEAR_MAINLOOP_INT(_ ## scale_func_name, scanline_func, src_type_t, mask_type_t,\
michael@0 535 + FAST_BILINEAR_MAINLOOP_INT(_ ## scale_func_name, fetch_func, op_func, src_type_t, mask_type_t,\
michael@0 536 dst_type_t, repeat_mode, flags)
michael@0 537
michael@0 538 #define SCALED_BILINEAR_FLAGS \
michael@0 539 (FAST_PATH_SCALE_TRANSFORM | \
michael@0 540 FAST_PATH_NO_ALPHA_MAP | \
michael@0 541 FAST_PATH_BILINEAR_FILTER | \
michael@0 542 FAST_PATH_NO_ACCESSORS | \
michael@0 543 FAST_PATH_NARROW_FORMAT)
michael@0 544 diff --git a/gfx/cairo/libpixman/src/pixman-sse2.c b/gfx/cairo/libpixman/src/pixman-sse2.c
michael@0 545 --- a/gfx/cairo/libpixman/src/pixman-sse2.c
michael@0 546 +++ b/gfx/cairo/libpixman/src/pixman-sse2.c
michael@0 547 @@ -5404,30 +5404,33 @@ scaled_bilinear_scanline_sse2_8888_8888_
michael@0 548 if (w & 1)
michael@0 549 {
michael@0 550 BILINEAR_INTERPOLATE_ONE_PIXEL (pix1);
michael@0 551 *dst = pix1;
michael@0 552 }
michael@0 553
michael@0 554 }
michael@0 555
michael@0 556 +/* Add extra NULL argument to the existing bilinear fast paths to indicate
michael@0 557 + * that we don't need two-pass processing */
michael@0 558 +
michael@0 559 FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_8888_cover_SRC,
michael@0 560 - scaled_bilinear_scanline_sse2_8888_8888_SRC,
michael@0 561 + scaled_bilinear_scanline_sse2_8888_8888_SRC, NULL,
michael@0 562 uint32_t, uint32_t, uint32_t,
michael@0 563 COVER, FLAG_NONE)
michael@0 564 FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_8888_pad_SRC,
michael@0 565 - scaled_bilinear_scanline_sse2_8888_8888_SRC,
michael@0 566 + scaled_bilinear_scanline_sse2_8888_8888_SRC, NULL,
michael@0 567 uint32_t, uint32_t, uint32_t,
michael@0 568 PAD, FLAG_NONE)
michael@0 569 FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_8888_none_SRC,
michael@0 570 - scaled_bilinear_scanline_sse2_8888_8888_SRC,
michael@0 571 + scaled_bilinear_scanline_sse2_8888_8888_SRC, NULL,
michael@0 572 uint32_t, uint32_t, uint32_t,
michael@0 573 NONE, FLAG_NONE)
michael@0 574 FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_8888_normal_SRC,
michael@0 575 - scaled_bilinear_scanline_sse2_8888_8888_SRC,
michael@0 576 + scaled_bilinear_scanline_sse2_8888_8888_SRC, NULL,
michael@0 577 uint32_t, uint32_t, uint32_t,
michael@0 578 NORMAL, FLAG_NONE)
michael@0 579
michael@0 580 static force_inline void
michael@0 581 scaled_bilinear_scanline_sse2_8888_8888_OVER (uint32_t * dst,
michael@0 582 const uint32_t * mask,
michael@0 583 const uint32_t * src_top,
michael@0 584 const uint32_t * src_bottom,
michael@0 585 @@ -5505,32 +5508,66 @@ scaled_bilinear_scanline_sse2_8888_8888_
michael@0 586 }
michael@0 587
michael@0 588 w--;
michael@0 589 dst++;
michael@0 590 }
michael@0 591 }
michael@0 592
michael@0 593 FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_8888_cover_OVER,
michael@0 594 - scaled_bilinear_scanline_sse2_8888_8888_OVER,
michael@0 595 + scaled_bilinear_scanline_sse2_8888_8888_OVER, NULL,
michael@0 596 uint32_t, uint32_t, uint32_t,
michael@0 597 COVER, FLAG_NONE)
michael@0 598 FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_8888_pad_OVER,
michael@0 599 - scaled_bilinear_scanline_sse2_8888_8888_OVER,
michael@0 600 + scaled_bilinear_scanline_sse2_8888_8888_OVER, NULL,
michael@0 601 uint32_t, uint32_t, uint32_t,
michael@0 602 PAD, FLAG_NONE)
michael@0 603 FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_8888_none_OVER,
michael@0 604 - scaled_bilinear_scanline_sse2_8888_8888_OVER,
michael@0 605 + scaled_bilinear_scanline_sse2_8888_8888_OVER, NULL,
michael@0 606 uint32_t, uint32_t, uint32_t,
michael@0 607 NONE, FLAG_NONE)
michael@0 608 FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_8888_normal_OVER,
michael@0 609 - scaled_bilinear_scanline_sse2_8888_8888_OVER,
michael@0 610 + scaled_bilinear_scanline_sse2_8888_8888_OVER, NULL,
michael@0 611 uint32_t, uint32_t, uint32_t,
michael@0 612 NORMAL, FLAG_NONE)
michael@0 613
michael@0 614 +
michael@0 615 +/* An example of SSE2 two-stage bilinear_over_8888_0565 fast path, which is implemented
michael@0 616 + as scaled_bilinear_scanline_sse2_8888_8888_SRC + op_bilinear_over_8888_0565 */
michael@0 617 +
michael@0 618 +void op_bilinear_over_8888_0565(uint16_t *dst, const uint32_t *mask, const uint32_t *src, int width)
michael@0 619 +{
michael@0 620 + /* Note: this is not really fast and should be based on 8 pixel loop from sse2_composite_over_8888_0565 */
michael@0 621 + while (--width >= 0)
michael@0 622 + {
michael@0 623 + *dst = composite_over_8888_0565pixel (*src, *dst);
michael@0 624 + src++;
michael@0 625 + dst++;
michael@0 626 + }
michael@0 627 +}
michael@0 628 +
michael@0 629 +FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_0565_cover_OVER,
michael@0 630 + scaled_bilinear_scanline_sse2_8888_8888_SRC, op_bilinear_over_8888_0565,
michael@0 631 + uint32_t, uint32_t, uint16_t,
michael@0 632 + COVER, FLAG_NONE)
michael@0 633 +FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_0565_pad_OVER,
michael@0 634 + scaled_bilinear_scanline_sse2_8888_8888_SRC, op_bilinear_over_8888_0565,
michael@0 635 + uint32_t, uint32_t, uint16_t,
michael@0 636 + PAD, FLAG_NONE)
michael@0 637 +FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_0565_none_OVER,
michael@0 638 + scaled_bilinear_scanline_sse2_8888_8888_SRC, op_bilinear_over_8888_0565,
michael@0 639 + uint32_t, uint32_t, uint16_t,
michael@0 640 + NONE, FLAG_NONE)
michael@0 641 +FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_0565_normal_OVER,
michael@0 642 + scaled_bilinear_scanline_sse2_8888_8888_SRC, op_bilinear_over_8888_0565,
michael@0 643 + uint32_t, uint32_t, uint16_t,
michael@0 644 + NORMAL, FLAG_NONE)
michael@0 645 +
michael@0 646 +/*****************************/
michael@0 647 +
michael@0 648 static force_inline void
michael@0 649 scaled_bilinear_scanline_sse2_8888_8_8888_OVER (uint32_t * dst,
michael@0 650 const uint8_t * mask,
michael@0 651 const uint32_t * src_top,
michael@0 652 const uint32_t * src_bottom,
michael@0 653 int32_t w,
michael@0 654 int wt,
michael@0 655 int wb,
michael@0 656 @@ -5669,29 +5706,29 @@ scaled_bilinear_scanline_sse2_8888_8_888
michael@0 657 }
michael@0 658
michael@0 659 w--;
michael@0 660 dst++;
michael@0 661 }
michael@0 662 }
michael@0 663
michael@0 664 FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_8_8888_cover_OVER,
michael@0 665 - scaled_bilinear_scanline_sse2_8888_8_8888_OVER,
michael@0 666 + scaled_bilinear_scanline_sse2_8888_8_8888_OVER, NULL,
michael@0 667 uint32_t, uint8_t, uint32_t,
michael@0 668 COVER, FLAG_HAVE_NON_SOLID_MASK)
michael@0 669 FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_8_8888_pad_OVER,
michael@0 670 - scaled_bilinear_scanline_sse2_8888_8_8888_OVER,
michael@0 671 + scaled_bilinear_scanline_sse2_8888_8_8888_OVER, NULL,
michael@0 672 uint32_t, uint8_t, uint32_t,
michael@0 673 PAD, FLAG_HAVE_NON_SOLID_MASK)
michael@0 674 FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_8_8888_none_OVER,
michael@0 675 - scaled_bilinear_scanline_sse2_8888_8_8888_OVER,
michael@0 676 + scaled_bilinear_scanline_sse2_8888_8_8888_OVER, NULL,
michael@0 677 uint32_t, uint8_t, uint32_t,
michael@0 678 NONE, FLAG_HAVE_NON_SOLID_MASK)
michael@0 679 FAST_BILINEAR_MAINLOOP_COMMON (sse2_8888_8_8888_normal_OVER,
michael@0 680 - scaled_bilinear_scanline_sse2_8888_8_8888_OVER,
michael@0 681 + scaled_bilinear_scanline_sse2_8888_8_8888_OVER, NULL,
michael@0 682 uint32_t, uint8_t, uint32_t,
michael@0 683 NORMAL, FLAG_HAVE_NON_SOLID_MASK)
michael@0 684
michael@0 685 static const pixman_fast_path_t sse2_fast_paths[] =
michael@0 686 {
michael@0 687 /* PIXMAN_OP_OVER */
michael@0 688 PIXMAN_STD_FAST_PATH (OVER, solid, a8, r5g6b5, sse2_composite_over_n_8_0565),
michael@0 689 PIXMAN_STD_FAST_PATH (OVER, solid, a8, b5g6r5, sse2_composite_over_n_8_0565),
michael@0 690 @@ -5808,16 +5845,21 @@ static const pixman_fast_path_t sse2_fas
michael@0 691 SIMPLE_BILINEAR_FAST_PATH (OVER, a8r8g8b8, a8r8g8b8, sse2_8888_8888),
michael@0 692 SIMPLE_BILINEAR_FAST_PATH (OVER, a8b8g8r8, a8b8g8r8, sse2_8888_8888),
michael@0 693
michael@0 694 SIMPLE_BILINEAR_A8_MASK_FAST_PATH (OVER, a8r8g8b8, x8r8g8b8, sse2_8888_8_8888),
michael@0 695 SIMPLE_BILINEAR_A8_MASK_FAST_PATH (OVER, a8b8g8r8, x8b8g8r8, sse2_8888_8_8888),
michael@0 696 SIMPLE_BILINEAR_A8_MASK_FAST_PATH (OVER, a8r8g8b8, a8r8g8b8, sse2_8888_8_8888),
michael@0 697 SIMPLE_BILINEAR_A8_MASK_FAST_PATH (OVER, a8b8g8r8, a8b8g8r8, sse2_8888_8_8888),
michael@0 698
michael@0 699 + /* and here the needed entries are added to the fast path table */
michael@0 700 +
michael@0 701 + SIMPLE_BILINEAR_FAST_PATH (OVER, a8r8g8b8, r5g6b5, sse2_8888_0565),
michael@0 702 + SIMPLE_BILINEAR_FAST_PATH (OVER, a8b8g8r8, b5g6r5, sse2_8888_0565),
michael@0 703 +
michael@0 704 { PIXMAN_OP_NONE },
michael@0 705 };
michael@0 706
michael@0 707 static pixman_bool_t
michael@0 708 sse2_blt (pixman_implementation_t *imp,
michael@0 709 uint32_t * src_bits,
michael@0 710 uint32_t * dst_bits,
michael@0 711 int src_stride,
michael@0 712

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial