Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / libcore / 319a3b994703aac84df7bcde272adfcb3cdbbbf0 / . / jdk / src / solaris / native / sun / java2d / loops / vis_XorBlit.c
blob: 442968ea9b3662f27aa60dd97aaadd5212403f53 [file] [log] [blame]
J. Duke319a3b92007-12-01 00:00:00 +0000[diff] [blame^]1/*
2 * Copyright 2003 Sun Microsystems, Inc. All Rights Reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Sun designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Sun in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22 * CA 95054 USA or visit www.sun.com if you need additional information or
23 * have any questions.
24 */
25
26#if !defined(JAVA2D_NO_MLIB) || defined(MLIB_ADD_SUFF)
27
28#include <vis_proto.h>
29#include "java2d_Mlib.h"
30
31/***************************************************************/
32
33#define ARGB_XOR(index, chan) \
34{ \
35 jint srcpixel = src_ptr[index]; \
36 jint neg_mask = srcpixel >> 31; \
37 dst_ptr[index] ^= (srcpixel ^ xorpixel) & (neg_mask &~ alphamask); \
38}
39
40/***************************************************************/
41
42#define BGR_XOR(index, chan) \
43{ \
44 jint srcpixel = src_ptr[index]; \
45 jint neg_mask = srcpixel >> 31; \
46 srcpixel = (srcpixel << 16) | (srcpixel & 0xff00) | \
47 ((srcpixel >> 16) & 0xff); \
48 dst_ptr[index] ^= (srcpixel ^ xorpixel) & (neg_mask &~ alphamask); \
49}
50
51/***************************************************************/
52
53#define ARGB_BM_XOR(index, chan) \
54{ \
55 jint srcpixel = src_ptr[index]; \
56 jint neg_mask = srcpixel >> 31; \
57 srcpixel |= 0xFF000000; \
58 dst_ptr[index] ^= (srcpixel ^ xorpixel) & (neg_mask &~ alphamask); \
59}
60
61/***************************************************************/
62
63#define RGBX_XOR(index, chan) \
64{ \
65 jint srcpixel = src_ptr[index]; \
66 jint neg_mask = srcpixel >> 31; \
67 dst_ptr[index] ^= ((srcpixel << 8) ^ xorpixel) & \
68 (neg_mask &~ alphamask); \
69}
70
71/***************************************************************/
72
73#define ARGB_to_GBGR_FL2(dst, src0, src1) { \
74 mlib_d64 t0, t1, t2; \
75 t0 = vis_fpmerge(src0, src1); \
76 t1 = vis_fpmerge(vis_read_lo(t0), vis_read_hi(t0)); \
77 t2 = vis_fpmerge(vis_read_lo(t0), vis_read_lo(t0)); \
78 dst = vis_fpmerge(vis_read_hi(t2), vis_read_lo(t1)); \
79}
80
81/***************************************************************/
82
83#ifdef MLIB_ADD_SUFF
84#pragma weak IntArgbToIntRgbXorBlit_F = IntArgbToIntArgbXorBlit_F
85#else
86#pragma weak IntArgbToIntRgbXorBlit = IntArgbToIntArgbXorBlit
87#endif
88
89/***************************************************************/
90
91void ADD_SUFF(IntArgbToIntArgbXorBlit)(BLIT_PARAMS)
92{
93 mlib_s32 dstScan = pDstInfo->scanStride;
94 mlib_s32 srcScan = pSrcInfo->scanStride;
95 mlib_s32 xorpixel = pCompInfo->details.xorPixel;
96 mlib_s32 alphamask = pCompInfo->alphaMask;
97 mlib_s32 i, j;
98 mlib_d64 res, xorpixel64, alphamask64, dzero;
99
100 if (width < 8) {
101 LOOP_DST_SRC(AnyInt, 1, dstBase, dstScan, srcBase, srcScan, ARGB_XOR);
102 return;
103 }
104
105 if (dstScan == 4*width && srcScan == dstScan) {
106 width *= height;
107 height = 1;
108 }
109
110 xorpixel64 = vis_to_double_dup(xorpixel);
111 alphamask64 = vis_to_double_dup(alphamask);
112 dzero = vis_fzero();
113
114 for (j = 0; j < height; j++) {
115 mlib_s32 *dst_ptr = dstBase;
116 mlib_s32 *src_ptr = srcBase;
117 mlib_s32 size = width;
118
119 if ((mlib_s32)dst_ptr & 7) {
120 ARGB_XOR(0, 0);
121 dst_ptr++;
122 src_ptr++;
123 size--;
124 }
125
126#pragma pipeloop(0)
127 for (i = 0; i <= size - 2; i += 2) {
128 mlib_s32 neg_mask;
129 mlib_f32 *pp0 = (mlib_f32*)src_ptr + i;
130 mlib_f32 *pp1 = (mlib_f32*)src_ptr + i + 1;
131 neg_mask = (((*(mlib_u8*)pp0) >> 6) & 2) | ((*(mlib_u8*)pp1) >> 7);
132 res = vis_freg_pair(*pp0, *pp1);
133 res = vis_fxor(res, xorpixel64);
134 res = vis_fandnot(alphamask64, res);
135 res = vis_fxor(res, *(mlib_d64*)(dst_ptr + i));
136 vis_pst_32(res, dst_ptr + i, neg_mask);
137 }
138
139 if (i < size) {
140 ARGB_XOR(i, 0);
141 }
142
143 PTR_ADD(dstBase, dstScan);
144 PTR_ADD(srcBase, srcScan);
145 }
146}
147
148/***************************************************************/
149
150void ADD_SUFF(IntArgbToIntBgrXorBlit)(BLIT_PARAMS)
151{
152 mlib_s32 dstScan = pDstInfo->scanStride;
153 mlib_s32 srcScan = pSrcInfo->scanStride;
154 mlib_s32 xorpixel = pCompInfo->details.xorPixel;
155 mlib_s32 alphamask = pCompInfo->alphaMask;
156 mlib_s32 i, j;
157 mlib_d64 res, xorpixel64, alphamask64, dzero;
158
159 if (width < 8) {
160 LOOP_DST_SRC(AnyInt, 1, dstBase, dstScan, srcBase, srcScan, BGR_XOR);
161 return;
162 }
163
164 if (dstScan == 4*width && srcScan == dstScan) {
165 width *= height;
166 height = 1;
167 }
168
169 xorpixel64 = vis_to_double_dup(xorpixel);
170 alphamask64 = vis_to_double_dup(alphamask);
171 dzero = vis_fzero();
172
173 for (j = 0; j < height; j++) {
174 mlib_s32 *dst_ptr = dstBase;
175 mlib_s32 *src_ptr = srcBase;
176 mlib_s32 size = width;
177
178 if ((mlib_s32)dst_ptr & 7) {
179 BGR_XOR(0, 0);
180 dst_ptr++;
181 src_ptr++;
182 size--;
183 }
184
185#pragma pipeloop(0)
186 for (i = 0; i <= size - 2; i += 2) {
187 mlib_s32 neg_mask;
188 mlib_f32 *pp0 = (mlib_f32*)src_ptr + i;
189 mlib_f32 *pp1 = (mlib_f32*)src_ptr + i + 1;
190 neg_mask = (((*(mlib_u8*)pp0) >> 6) & 2) | ((*(mlib_u8*)pp1) >> 7);
191 ARGB_to_GBGR_FL2(res, *pp0, *pp1);
192 res = vis_fxor(res, xorpixel64);
193 res = vis_fandnot(alphamask64, res);
194 res = vis_fxor(res, *(mlib_d64*)(dst_ptr + i));
195 vis_pst_32(res, dst_ptr + i, neg_mask);
196 }
197
198 if (i < size) {
199 BGR_XOR(i, 0);
200 }
201
202 PTR_ADD(dstBase, dstScan);
203 PTR_ADD(srcBase, srcScan);
204 }
205}
206
207/***************************************************************/
208
209void ADD_SUFF(IntArgbToIntArgbBmXorBlit)(BLIT_PARAMS)
210{
211 mlib_s32 dstScan = pDstInfo->scanStride;
212 mlib_s32 srcScan = pSrcInfo->scanStride;
213 mlib_s32 xorpixel = pCompInfo->details.xorPixel;
214 mlib_s32 alphamask = pCompInfo->alphaMask;
215 mlib_s32 i, j, neg_mask;
216 mlib_d64 res, xorpixel64, alphamask64, dzero, dFF;
217
218 if (width < 8) {
219 LOOP_DST_SRC(AnyInt, 1, dstBase, dstScan, srcBase, srcScan,
220 ARGB_BM_XOR);
221 return;
222 }
223
224 if (dstScan == 4*width && srcScan == dstScan) {
225 width *= height;
226 height = 1;
227 }
228
229 xorpixel64 = vis_to_double_dup(xorpixel);
230 alphamask64 = vis_to_double_dup(alphamask);
231 dzero = vis_fzero();
232 dFF = vis_to_double_dup(0xFF000000);
233
234 for (j = 0; j < height; j++) {
235 mlib_s32 *dst_ptr = dstBase;
236 mlib_s32 *src_ptr = srcBase;
237 mlib_s32 size = width;
238
239 if ((mlib_s32)dst_ptr & 7) {
240 ARGB_BM_XOR(0, 0);
241 dst_ptr++;
242 src_ptr++;
243 size--;
244 }
245
246#pragma pipeloop(0)
247 for (i = 0; i <= size - 2; i += 2) {
248 mlib_s32 neg_mask;
249 mlib_f32 *pp0 = (mlib_f32*)src_ptr + i;
250 mlib_f32 *pp1 = (mlib_f32*)src_ptr + i + 1;
251 neg_mask = (((*(mlib_u8*)pp0) >> 6) & 2) | ((*(mlib_u8*)pp1) >> 7);
252 res = vis_freg_pair(*pp0, *pp1);
253 res = vis_for(res, dFF);
254 res = vis_fxor(res, xorpixel64);
255 res = vis_fandnot(alphamask64, res);
256 res = vis_fxor(res, *(mlib_d64*)(dst_ptr + i));
257 vis_pst_32(res, dst_ptr + i, neg_mask);
258 }
259
260 if (i < size) {
261 ARGB_BM_XOR(i, 0);
262 }
263
264 PTR_ADD(dstBase, dstScan);
265 PTR_ADD(srcBase, srcScan);
266 }
267}
268
269/***************************************************************/
270
271void ADD_SUFF(IntArgbToIntRgbxXorBlit)(BLIT_PARAMS)
272{
273 mlib_s32 dstScan = pDstInfo->scanStride;
274 mlib_s32 srcScan = pSrcInfo->scanStride;
275 mlib_s32 xorpixel = pCompInfo->details.xorPixel;
276 mlib_s32 alphamask = pCompInfo->alphaMask;
277 mlib_s32 i, j, neg_mask;
278 mlib_d64 res, xorpixel64, alphamask64, rgbx_mask, dzero;
279
280 if (width < 8) {
281 LOOP_DST_SRC(AnyInt, 1, dstBase, dstScan, srcBase, srcScan, RGBX_XOR);
282 return;
283 }
284
285 if (dstScan == 4*width && srcScan == dstScan) {
286 width *= height;
287 height = 1;
288 }
289
290 xorpixel64 = vis_to_double_dup(xorpixel);
291 alphamask64 = vis_to_double_dup(alphamask);
292 rgbx_mask = vis_to_double_dup(0xFFFFFF00);
293 dzero = vis_fzero();
294
295 vis_alignaddr(NULL, 1);
296
297 for (j = 0; j < height; j++) {
298 mlib_s32 *dst_ptr = dstBase;
299 mlib_s32 *src_ptr = srcBase;
300 mlib_s32 size = width;
301
302 if ((mlib_s32)dst_ptr & 7) {
303 RGBX_XOR(0, 0);
304 dst_ptr++;
305 src_ptr++;
306 size--;
307 }
308
309#pragma pipeloop(0)
310 for (i = 0; i <= size - 2; i += 2) {
311 mlib_s32 neg_mask;
312 mlib_f32 *pp0 = (mlib_f32*)src_ptr + i;
313 mlib_f32 *pp1 = (mlib_f32*)src_ptr + i + 1;
314 neg_mask = (((*(mlib_u8*)pp0) >> 6) & 2) | ((*(mlib_u8*)pp1) >> 7);
315 res = vis_freg_pair(*pp0, *pp1);
316 res = vis_fand(vis_faligndata(res, res), rgbx_mask);
317 res = vis_fxor(res, xorpixel64);
318 res = vis_fandnot(alphamask64, res);
319 res = vis_fxor(res, *(mlib_d64*)(dst_ptr + i));
320 vis_pst_32(res, dst_ptr + i, neg_mask);
321 }
322
323 if (i < size) {
324 RGBX_XOR(i, 0);
325 }
326
327 PTR_ADD(dstBase, dstScan);
328 PTR_ADD(srcBase, srcScan);
329 }
330}
331
332/***************************************************************/
333
334void ADD_SUFF(IntArgbToFourByteAbgrPreXorBlit)(BLIT_PARAMS)
335{
336 jint xorpixel = pCompInfo->details.xorPixel;
337 juint alphamask = pCompInfo->alphaMask;
338 jint xor0, xor1, xor2, xor3;
339 jint mask0, mask1, mask2, mask3;
340 jint *pSrc = srcBase;
341 jubyte *pDst = dstBase;
342 jint srcScan = pSrcInfo->scanStride;
343 jint dstScan = pDstInfo->scanStride;
344
345 xor0 = xorpixel;
346 xor1 = xorpixel >> 8;
347 xor2 = xorpixel >> 16;
348 xor3 = xorpixel >> 24;
349 mask0 = alphamask;
350 mask1 = alphamask >> 8;
351 mask2 = alphamask >> 16;
352 mask3 = alphamask >> 24;
353
354 srcScan -= width * 4;
355 dstScan -= width * 4;
356
357 do {
358 juint w = width;;
359 do {
360 jint srcpixel;
361 jint a, r, g, b;
362
363 srcpixel = pSrc[0];
364 b = srcpixel & 0xff;
365 g = (srcpixel >> 8) & 0xff;
366 r = (srcpixel >> 16) & 0xff;
367 a = (mlib_u32)srcpixel >> 24;
368
369 if (srcpixel < 0) {
370 r = mul8table[a][r];
371 g = mul8table[a][g];
372 b = mul8table[a][b];
373
374 pDst[0] ^= (a ^ xor0) & ~mask0;
375 pDst[1] ^= (b ^ xor1) & ~mask1;
376 pDst[2] ^= (g ^ xor2) & ~mask2;
377 pDst[3] ^= (r ^ xor3) & ~mask3;
378 }
379 pSrc = ((void *) (((intptr_t) (pSrc)) + (4)));
380 pDst = ((void *) (((intptr_t) (pDst)) + (4)));;
381 }
382 while (--w > 0);
383 pSrc = ((void *) (((intptr_t) (pSrc)) + (srcScan)));
384 pDst = ((void *) (((intptr_t) (pDst)) + (dstScan)));;
385 }
386 while (--height > 0);
387}
388
389/***************************************************************/
390
391#endif