1 /*
2 * Copyright (c) 2003, 2005, Oracle and/or its affiliates. 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. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #if !defined(JAVA2D_NO_MLIB) || defined(MLIB_ADD_SUFF)
27
28 #include "vis_AlphaMacros.h"
29
30 /***************************************************************/
31
32 /* ##############################################################
33 * IntArgbAlphaMaskFill()
34 * FourByteAbgrAlphaMaskFill()
35 */
36
37 #define MASK_FILL(rr, pathA, dstA, dstARGB) \
38 { \
39 mlib_d64 t0, t1; \
40 mlib_s32 srcF, dstF, srcA; \
41 \
42 srcF = ((dstA & SrcOpAnd) ^ SrcOpXor) + SrcOpAdd; \
43 \
44 srcF = MUL8_INT(srcF, pathA); \
45 dstF = mul8_dstF[pathA] + (0xff - pathA); \
46 \
47 srcA = mul8_cnstA[srcF]; \
48 dstA = MUL8_INT(dstF, dstA); \
49 \
50 t0 = MUL8_VIS(cnstARGB0, srcF); \
51 t1 = MUL8_VIS(dstARGB, dstA); \
52 rr = vis_fpadd16(t0, t1); \
53 \
54 dstA += srcA; \
55 DIV_ALPHA(rr, dstA); \
56 }
57
58 /***************************************************************/
59
IntArgbAlphaMaskFill_line(mlib_f32 * dst_ptr,mlib_u8 * pMask,mlib_s32 width,mlib_f32 cnstARGB0,mlib_s32 * log_val,mlib_u8 * mul8_cnstA,mlib_u8 * mul8_dstF,mlib_u8 * mul8_tbl)60 static void IntArgbAlphaMaskFill_line(mlib_f32 *dst_ptr,
61 mlib_u8 *pMask,
62 mlib_s32 width,
63 mlib_f32 cnstARGB0,
64 mlib_s32 *log_val,
65 mlib_u8 *mul8_cnstA,
66 mlib_u8 *mul8_dstF,
67 mlib_u8 *mul8_tbl)
68 {
69 mlib_s32 i, i0;
70 mlib_s32 pathA0, pathA1, dstA0, dstA1, msk;
71 mlib_d64 res0, res1, dstARGB;
72 mlib_f32 dstARGB0;
73 mlib_s32 SrcOpAnd, SrcOpXor, SrcOpAdd;
74
75 SrcOpAnd = log_val[0];
76 SrcOpXor = log_val[1];
77 SrcOpAdd = log_val[2];
78
79 i = i0 = 0;
80
81 if ((mlib_s32)dst_ptr & 7) {
82 pathA0 = pMask[i];
83
84 if (pathA0) {
85 dstA0 = *(mlib_u8*)(dst_ptr + i);
86 dstARGB0 = dst_ptr[i];
87 MASK_FILL(res0, pathA0, dstA0, dstARGB0);
88 dst_ptr[i] = vis_fpack16(res0);
89 *(mlib_u8*)(dst_ptr + i) = dstA0;
90 }
91
92 i0 = 1;
93 }
94
95 #pragma pipeloop(0)
96 for (i = i0; i <= width - 2; i += 2) {
97 pathA0 = pMask[i];
98 pathA1 = pMask[i + 1];
99 dstA0 = *(mlib_u8*)(dst_ptr + i);
100 dstA1 = *(mlib_u8*)(dst_ptr + i + 1);
101 dstARGB = *(mlib_d64*)(dst_ptr + i);
102
103 MASK_FILL(res0, pathA0, dstA0, vis_read_hi(dstARGB));
104 MASK_FILL(res1, pathA1, dstA1, vis_read_lo(dstARGB));
105
106 res0 = vis_fpack16_pair(res0, res1);
107
108 msk = (((-pathA0) & (1 << 11)) | ((-pathA1) & (1 << 10))) >> 10;
109 vis_pst_32(res0, dst_ptr + i, msk);
110
111 *(mlib_u8*)(dst_ptr + i ) = dstA0;
112 *(mlib_u8*)(dst_ptr + i + 1) = dstA1;
113 }
114
115 if (i < width) {
116 pathA0 = pMask[i];
117
118 if (pathA0) {
119 dstA0 = *(mlib_u8*)(dst_ptr + i);
120 dstARGB0 = dst_ptr[i];
121 MASK_FILL(res0, pathA0, dstA0, dstARGB0);
122 dst_ptr[i] = vis_fpack16(res0);
123 *(mlib_u8*)(dst_ptr + i) = dstA0;
124 }
125 }
126 }
127
128 /***************************************************************/
129
130 #undef MASK_FILL
131 #define MASK_FILL(rr, pathA, dstA, dstARGB) \
132 { \
133 mlib_d64 t0, t1; \
134 mlib_s32 srcA, alp1; \
135 \
136 srcA = ((dstA & SrcOpAnd) ^ SrcOpXor) + SrcOpAdd; \
137 alp1 = mul8_dstF[dstA]; \
138 dstA = mul8_cnstA[srcA] + alp1; \
139 \
140 t0 = MUL8_VIS(cnstARGB0, srcA); \
141 t1 = MUL8_VIS(dstARGB, alp1); \
142 rr = vis_fpadd16(t0, t1); \
143 \
144 DIV_ALPHA(rr, dstA); \
145 }
146
147 /***************************************************************/
148
IntArgbAlphaMaskFill_A1_line(mlib_f32 * dst_ptr,mlib_u8 * pMask,mlib_s32 width,mlib_f32 cnstARGB0,mlib_s32 * log_val,mlib_u8 * mul8_cnstA,mlib_u8 * mul8_dstF,mlib_u8 * mul8_tbl)149 static void IntArgbAlphaMaskFill_A1_line(mlib_f32 *dst_ptr,
150 mlib_u8 *pMask,
151 mlib_s32 width,
152 mlib_f32 cnstARGB0,
153 mlib_s32 *log_val,
154 mlib_u8 *mul8_cnstA,
155 mlib_u8 *mul8_dstF,
156 mlib_u8 *mul8_tbl)
157 {
158 mlib_s32 i;
159 mlib_s32 dstA0;
160 mlib_d64 res0;
161 mlib_f32 dstARGB0;
162 mlib_s32 SrcOpAnd, SrcOpXor, SrcOpAdd;
163
164 SrcOpAnd = log_val[0];
165 SrcOpXor = log_val[1];
166 SrcOpAdd = log_val[2];
167
168 #pragma pipeloop(0)
169 for (i = 0; i < width; i++) {
170 dstA0 = *(mlib_u8*)(dst_ptr + i);
171 dstARGB0 = dst_ptr[i];
172 MASK_FILL(res0, pathA0, dstA0, dstARGB0);
173 dst_ptr[i] = vis_fpack16(res0);
174 *(mlib_u8*)(dst_ptr + i) = dstA0;
175 }
176 }
177
178 /***************************************************************/
179
ADD_SUFF(IntArgbAlphaMaskFill)180 void ADD_SUFF(IntArgbAlphaMaskFill)(void *rasBase,
181 jubyte *pMask,
182 jint maskOff,
183 jint maskScan,
184 jint width,
185 jint height,
186 jint fgColor,
187 SurfaceDataRasInfo *pRasInfo,
188 NativePrimitive *pPrim,
189 CompositeInfo *pCompInfo)
190 {
191 mlib_s32 cnstA, cnstR, cnstG, cnstB;
192 mlib_s32 rasScan = pRasInfo->scanStride;
193 mlib_f32 cnstARGB0;
194 mlib_u8 *mul8_cnstA, *mul8_dstF;
195 mlib_s32 SrcOpAnd, SrcOpXor, SrcOpAdd;
196 mlib_s32 DstOpAnd, DstOpXor, DstOpAdd;
197 mlib_s32 dstF;
198 mlib_s32 log_val[3];
199 mlib_s32 j;
200
201 cnstA = (fgColor >> 24) & 0xff;
202 cnstR = (fgColor >> 16) & 0xff;
203 cnstG = (fgColor >> 8) & 0xff;
204 cnstB = (fgColor ) & 0xff;
205
206 if (cnstA != 0xff) {
207 cnstR = mul8table[cnstA][cnstR];
208 cnstG = mul8table[cnstA][cnstG];
209 cnstB = mul8table[cnstA][cnstB];
210 }
211
212 cnstARGB0 = F32_FROM_U8x4(cnstA, cnstR, cnstG, cnstB);
213
214 SrcOpAnd = (AlphaRules[pCompInfo->rule].srcOps).andval;
215 SrcOpXor = (AlphaRules[pCompInfo->rule].srcOps).xorval;
216 SrcOpAdd = (AlphaRules[pCompInfo->rule].srcOps).addval;
217 SrcOpAdd -= SrcOpXor;
218
219 log_val[0] = SrcOpAnd;
220 log_val[1] = SrcOpXor;
221 log_val[2] = SrcOpAdd;
222
223 DstOpAnd = (AlphaRules[pCompInfo->rule].dstOps).andval;
224 DstOpXor = (AlphaRules[pCompInfo->rule].dstOps).xorval;
225 DstOpAdd = (AlphaRules[pCompInfo->rule].dstOps).addval;
226 DstOpAdd -= DstOpXor;
227
228 dstF = (((cnstA) & DstOpAnd) ^ DstOpXor) + DstOpAdd;
229
230 mul8_cnstA = mul8table[cnstA];
231 mul8_dstF = mul8table[dstF];
232
233 vis_write_gsr(7 << 3);
234
235 if (pMask != NULL) {
236 pMask += maskOff;
237
238 if (rasScan == 4*width && maskScan == width) {
239 width *= height;
240 height = 1;
241 }
242
243 for (j = 0; j < height; j++) {
244 IntArgbAlphaMaskFill_line(rasBase, pMask, width, cnstARGB0,
245 log_val, mul8_cnstA, mul8_dstF,
246 (void*)mul8table);
247
248 PTR_ADD(rasBase, rasScan);
249 PTR_ADD(pMask, maskScan);
250 }
251 } else {
252 if (rasScan == 4*width) {
253 width *= height;
254 height = 1;
255 }
256
257 for (j = 0; j < height; j++) {
258 IntArgbAlphaMaskFill_A1_line(rasBase, pMask, width, cnstARGB0,
259 log_val, mul8_cnstA, mul8_dstF,
260 (void*)mul8table);
261
262 PTR_ADD(rasBase, rasScan);
263 }
264 }
265 }
266
267 /***************************************************************/
268
ADD_SUFF(FourByteAbgrAlphaMaskFill)269 void ADD_SUFF(FourByteAbgrAlphaMaskFill)(void *rasBase,
270 jubyte *pMask,
271 jint maskOff,
272 jint maskScan,
273 jint width,
274 jint height,
275 jint fgColor,
276 SurfaceDataRasInfo *pRasInfo,
277 NativePrimitive *pPrim,
278 CompositeInfo *pCompInfo)
279 {
280 mlib_d64 buff[BUFF_SIZE/2];
281 void *pbuff = buff;
282 mlib_s32 cnstA, cnstR, cnstG, cnstB;
283 mlib_s32 rasScan = pRasInfo->scanStride;
284 mlib_f32 cnstARGB0;
285 mlib_u8 *mul8_cnstA, *mul8_dstF;
286 mlib_s32 SrcOpAnd, SrcOpXor, SrcOpAdd;
287 mlib_s32 DstOpAnd, DstOpXor, DstOpAdd;
288 mlib_s32 dstF;
289 mlib_s32 log_val[3];
290 mlib_s32 j;
291
292 cnstA = (mlib_u32)fgColor >> 24;
293 cnstR = (fgColor >> 16) & 0xff;
294 cnstG = (fgColor >> 8) & 0xff;
295 cnstB = (fgColor ) & 0xff;
296
297 if (cnstA != 0xff) {
298 cnstR = mul8table[cnstA][cnstR];
299 cnstG = mul8table[cnstA][cnstG];
300 cnstB = mul8table[cnstA][cnstB];
301 }
302
303 cnstARGB0 = F32_FROM_U8x4(cnstA, cnstB, cnstG, cnstR);
304
305 SrcOpAnd = (AlphaRules[pCompInfo->rule].srcOps).andval;
306 SrcOpXor = (AlphaRules[pCompInfo->rule].srcOps).xorval;
307 SrcOpAdd = (AlphaRules[pCompInfo->rule].srcOps).addval;
308 SrcOpAdd -= SrcOpXor;
309
310 log_val[0] = SrcOpAnd;
311 log_val[1] = SrcOpXor;
312 log_val[2] = SrcOpAdd;
313
314 DstOpAnd = (AlphaRules[pCompInfo->rule].dstOps).andval;
315 DstOpXor = (AlphaRules[pCompInfo->rule].dstOps).xorval;
316 DstOpAdd = (AlphaRules[pCompInfo->rule].dstOps).addval;
317 DstOpAdd -= DstOpXor;
318
319 dstF = (((cnstA) & DstOpAnd) ^ DstOpXor) + DstOpAdd;
320
321 mul8_cnstA = mul8table[cnstA];
322 mul8_dstF = mul8table[dstF];
323
324 vis_write_gsr(7 << 3);
325
326 if (pMask != NULL) {
327 pMask += maskOff;
328
329 if (((mlib_s32)rasBase | rasScan) & 3) {
330 if (width > BUFF_SIZE) pbuff = mlib_malloc(width*sizeof(mlib_s32));
331 } else {
332 if (rasScan == 4*width && maskScan == width) {
333 width *= height;
334 height = 1;
335 }
336 }
337
338 for (j = 0; j < height; j++) {
339 if (!((mlib_s32)rasBase & 3)) {
340 IntArgbAlphaMaskFill_line(rasBase, pMask, width, cnstARGB0,
341 log_val, mul8_cnstA, mul8_dstF,
342 (void*)mul8table);
343 } else {
344 mlib_ImageCopy_na(rasBase, pbuff, width*sizeof(mlib_s32));
345 IntArgbAlphaMaskFill_line(pbuff, pMask, width, cnstARGB0,
346 log_val, mul8_cnstA, mul8_dstF,
347 (void*)mul8table);
348 mlib_ImageCopy_na(pbuff, rasBase, width*sizeof(mlib_s32));
349 }
350
351 PTR_ADD(rasBase, rasScan);
352 PTR_ADD(pMask, maskScan);
353 }
354 } else {
355 if (((mlib_s32)rasBase | rasScan) & 3) {
356 if (width > BUFF_SIZE) pbuff = mlib_malloc(width*sizeof(mlib_s32));
357 } else {
358 if (rasScan == 4*width) {
359 width *= height;
360 height = 1;
361 }
362 }
363
364 for (j = 0; j < height; j++) {
365 if (!((mlib_s32)rasBase & 3)) {
366 IntArgbAlphaMaskFill_A1_line(rasBase, pMask, width, cnstARGB0,
367 log_val, mul8_cnstA, mul8_dstF,
368 (void*)mul8table);
369 } else {
370 mlib_ImageCopy_na(rasBase, pbuff, width*sizeof(mlib_s32));
371 IntArgbAlphaMaskFill_A1_line(pbuff, pMask, width, cnstARGB0,
372 log_val, mul8_cnstA, mul8_dstF,
373 (void*)mul8table);
374 mlib_ImageCopy_na(pbuff, rasBase, width*sizeof(mlib_s32));
375 }
376
377 PTR_ADD(rasBase, rasScan);
378 }
379 }
380
381 if (pbuff != buff) {
382 mlib_free(pbuff);
383 }
384 }
385
386 /***************************************************************/
387
388 /* ##############################################################
389 * IntRgbAlphaMaskFill()
390 * IntBgrAlphaMaskFill()
391 */
392
393 #undef MASK_FILL
394 #define MASK_FILL(rr, pathA, dstA, dstARGB) \
395 { \
396 mlib_d64 t0, t1; \
397 mlib_s32 srcF, srcA; \
398 \
399 srcF = mul8_srcF[pathA]; \
400 srcA = mul8_cnstA[srcF]; \
401 dstA = mul8_dstF[pathA] + (0xff - pathA); \
402 \
403 t0 = MUL8_VIS(cnstARGB0, srcF); \
404 t1 = MUL8_VIS(dstARGB, dstA); \
405 rr = vis_fpadd16(t0, t1); \
406 \
407 dstA += srcA; \
408 DIV_ALPHA_RGB(rr, dstA); \
409 \
410 pathA = dstA - 0xff - srcF; \
411 /* (pathA == 0) if (dstA == 0xFF && srcF == 0) */ \
412 }
413
414 /***************************************************************/
415
IntRgbAlphaMaskFill_line(mlib_f32 * dst_ptr,mlib_u8 * pMask,mlib_s32 width,mlib_f32 cnstARGB0,mlib_u8 * mul8_cnstA,mlib_u8 * mul8_dstF,mlib_u8 * mul8_srcF,mlib_u8 * mul8_tbl)416 static void IntRgbAlphaMaskFill_line(mlib_f32 *dst_ptr,
417 mlib_u8 *pMask,
418 mlib_s32 width,
419 mlib_f32 cnstARGB0,
420 mlib_u8 *mul8_cnstA,
421 mlib_u8 *mul8_dstF,
422 mlib_u8 *mul8_srcF,
423 mlib_u8 *mul8_tbl)
424 {
425 mlib_s32 i, i0;
426 mlib_s32 pathA0, pathA1, dstA0, dstA1, msk;
427 mlib_d64 res0, res1, dstARGB;
428 mlib_f32 dstARGB0;
429
430 i = i0 = 0;
431
432 if ((mlib_s32)dst_ptr & 7) {
433 pathA0 = pMask[i];
434
435 dstARGB0 = dst_ptr[i];
436 MASK_FILL(res0, pathA0, dstA0, dstARGB0);
437 if (pathA0) {
438 dst_ptr[i] = vis_fpack16(res0);
439 }
440
441 i0 = 1;
442 }
443
444 #pragma pipeloop(0)
445 for (i = i0; i <= width - 2; i += 2) {
446 pathA0 = pMask[i];
447 pathA1 = pMask[i + 1];
448 dstARGB = *(mlib_d64*)(dst_ptr + i);
449
450 MASK_FILL(res0, pathA0, dstA0, vis_read_hi(dstARGB));
451 MASK_FILL(res1, pathA1, dstA1, vis_read_lo(dstARGB));
452
453 res0 = vis_fpack16_pair(res0, res1);
454
455 msk = (((pathA0) & (1 << 11)) | ((pathA1) & (1 << 10))) >> 10;
456 vis_pst_32(res0, dst_ptr + i, msk);
457 }
458
459 if (i < width) {
460 pathA0 = pMask[i];
461
462 dstARGB0 = dst_ptr[i];
463 MASK_FILL(res0, pathA0, dstA0, dstARGB0);
464 if (pathA0) {
465 dst_ptr[i] = vis_fpack16(res0);
466 }
467 }
468 }
469
470 /***************************************************************/
471
472 #undef MASK_FILL
473 #define MASK_FILL(rr, pathA, _dstA_, dstARGB) \
474 { \
475 rr = MUL8_VIS(dstARGB, dstF); \
476 rr = vis_fpadd16(rr, cnstARGB); \
477 \
478 DIV_ALPHA_RGB(rr, dstA); \
479 }
480
481 /***************************************************************/
482
IntRgbAlphaMaskFill_A1_line(mlib_f32 * dst_ptr,mlib_u8 * pMask,mlib_s32 width,mlib_d64 cnstARGB,mlib_s32 dstF,mlib_s32 dstA)483 static void IntRgbAlphaMaskFill_A1_line(mlib_f32 *dst_ptr,
484 mlib_u8 *pMask,
485 mlib_s32 width,
486 mlib_d64 cnstARGB,
487 mlib_s32 dstF,
488 mlib_s32 dstA)
489 {
490 mlib_s32 i;
491 mlib_d64 res0;
492 mlib_f32 dstARGB0;
493
494 #pragma pipeloop(0)
495 for (i = 0; i < width; i++) {
496 dstARGB0 = dst_ptr[i];
497 MASK_FILL(res0, pathA0, dstA0, dstARGB0);
498 dst_ptr[i] = vis_fpack16(res0);
499 }
500 }
501
502 /***************************************************************/
503
ADD_SUFF(IntRgbAlphaMaskFill)504 void ADD_SUFF(IntRgbAlphaMaskFill)(void *rasBase,
505 jubyte *pMask,
506 jint maskOff,
507 jint maskScan,
508 jint width,
509 jint height,
510 jint fgColor,
511 SurfaceDataRasInfo *pRasInfo,
512 NativePrimitive *pPrim,
513 CompositeInfo *pCompInfo)
514 {
515 mlib_s32 cnstA, cnstR, cnstG, cnstB;
516 mlib_s32 rasScan = pRasInfo->scanStride;
517 mlib_f32 cnstARGB0;
518 mlib_u8 *mul8_cnstA, *mul8_dstF, *mul8_srcF;
519 mlib_s32 SrcOpAnd, SrcOpXor, SrcOpAdd;
520 mlib_s32 DstOpAnd, DstOpXor, DstOpAdd;
521 mlib_s32 srcF, dstF;
522 mlib_s32 log_val[3];
523 mlib_s32 j;
524
525 cnstA = (fgColor >> 24) & 0xff;
526 cnstR = (fgColor >> 16) & 0xff;
527 cnstG = (fgColor >> 8) & 0xff;
528 cnstB = (fgColor ) & 0xff;
529
530 if (cnstA != 0xff) {
531 cnstR = mul8table[cnstA][cnstR];
532 cnstG = mul8table[cnstA][cnstG];
533 cnstB = mul8table[cnstA][cnstB];
534 }
535
536 cnstARGB0 = F32_FROM_U8x4(cnstA, cnstR, cnstG, cnstB);
537
538 SrcOpAnd = (AlphaRules[pCompInfo->rule].srcOps).andval;
539 SrcOpXor = (AlphaRules[pCompInfo->rule].srcOps).xorval;
540 SrcOpAdd = (AlphaRules[pCompInfo->rule].srcOps).addval;
541 SrcOpAdd -= SrcOpXor;
542
543 log_val[0] = SrcOpAnd;
544 log_val[1] = SrcOpXor;
545 log_val[2] = SrcOpAdd;
546
547 DstOpAnd = (AlphaRules[pCompInfo->rule].dstOps).andval;
548 DstOpXor = (AlphaRules[pCompInfo->rule].dstOps).xorval;
549 DstOpAdd = (AlphaRules[pCompInfo->rule].dstOps).addval;
550 DstOpAdd -= DstOpXor;
551
552 dstF = (((cnstA) & DstOpAnd) ^ DstOpXor) + DstOpAdd;
553 srcF = ((( 255) & SrcOpAnd) ^ SrcOpXor) + SrcOpAdd;
554
555 vis_write_gsr(7 << 3);
556
557 mul8_cnstA = mul8table[cnstA];
558
559 if (pMask != NULL) {
560 pMask += maskOff;
561
562 mul8_dstF = mul8table[dstF];
563 mul8_srcF = mul8table[srcF];
564
565 if (rasScan == 4*width && maskScan == width) {
566 width *= height;
567 height = 1;
568 }
569
570 for (j = 0; j < height; j++) {
571 IntRgbAlphaMaskFill_line(rasBase, pMask, width, cnstARGB0,
572 mul8_cnstA, mul8_dstF, mul8_srcF,
573 (void*)mul8table);
574
575 PTR_ADD(rasBase, rasScan);
576 PTR_ADD(pMask, maskScan);
577 }
578 } else {
579 mlib_s32 dstA;
580 mlib_d64 cnstARGB;
581
582 if (dstF == 0xFF && srcF == 0) return;
583
584 cnstARGB = MUL8_VIS(cnstARGB0, srcF);
585 dstA = dstF + mul8_cnstA[srcF];
586
587 if (rasScan == 4*width) {
588 width *= height;
589 height = 1;
590 }
591
592 for (j = 0; j < height; j++) {
593 IntRgbAlphaMaskFill_A1_line(rasBase, pMask, width, cnstARGB,
594 dstF, dstA);
595
596 PTR_ADD(rasBase, rasScan);
597 }
598 }
599 }
600
601 /***************************************************************/
602
ADD_SUFF(IntBgrAlphaMaskFill)603 void ADD_SUFF(IntBgrAlphaMaskFill)(void *rasBase,
604 jubyte *pMask,
605 jint maskOff,
606 jint maskScan,
607 jint width,
608 jint height,
609 jint fgColor,
610 SurfaceDataRasInfo *pRasInfo,
611 NativePrimitive *pPrim,
612 CompositeInfo *pCompInfo)
613 {
614 mlib_s32 cnstA, cnstR, cnstG, cnstB;
615 mlib_s32 rasScan = pRasInfo->scanStride;
616 mlib_f32 cnstARGB0;
617 mlib_u8 *mul8_cnstA, *mul8_dstF, *mul8_srcF;
618 mlib_s32 SrcOpAnd, SrcOpXor, SrcOpAdd;
619 mlib_s32 DstOpAnd, DstOpXor, DstOpAdd;
620 mlib_s32 srcF, dstF;
621 mlib_s32 log_val[3];
622 mlib_s32 j;
623
624 cnstA = (fgColor >> 24) & 0xff;
625 cnstR = (fgColor >> 16) & 0xff;
626 cnstG = (fgColor >> 8) & 0xff;
627 cnstB = (fgColor ) & 0xff;
628
629 if (cnstA != 0xff) {
630 cnstR = mul8table[cnstA][cnstR];
631 cnstG = mul8table[cnstA][cnstG];
632 cnstB = mul8table[cnstA][cnstB];
633 }
634
635 cnstARGB0 = F32_FROM_U8x4(cnstA, cnstB, cnstG, cnstR);
636
637 SrcOpAnd = (AlphaRules[pCompInfo->rule].srcOps).andval;
638 SrcOpXor = (AlphaRules[pCompInfo->rule].srcOps).xorval;
639 SrcOpAdd = (AlphaRules[pCompInfo->rule].srcOps).addval;
640 SrcOpAdd -= SrcOpXor;
641
642 log_val[0] = SrcOpAnd;
643 log_val[1] = SrcOpXor;
644 log_val[2] = SrcOpAdd;
645
646 DstOpAnd = (AlphaRules[pCompInfo->rule].dstOps).andval;
647 DstOpXor = (AlphaRules[pCompInfo->rule].dstOps).xorval;
648 DstOpAdd = (AlphaRules[pCompInfo->rule].dstOps).addval;
649 DstOpAdd -= DstOpXor;
650
651 dstF = (((cnstA) & DstOpAnd) ^ DstOpXor) + DstOpAdd;
652 srcF = ((( 255) & SrcOpAnd) ^ SrcOpXor) + SrcOpAdd;
653
654 vis_write_gsr(7 << 3);
655
656 mul8_cnstA = mul8table[cnstA];
657
658 if (pMask != NULL) {
659 pMask += maskOff;
660
661 mul8_dstF = mul8table[dstF];
662 mul8_srcF = mul8table[srcF];
663
664 if (rasScan == 4*width && maskScan == width) {
665 width *= height;
666 height = 1;
667 }
668
669 for (j = 0; j < height; j++) {
670 IntRgbAlphaMaskFill_line(rasBase, pMask, width, cnstARGB0,
671 mul8_cnstA, mul8_dstF, mul8_srcF,
672 (void*)mul8table);
673
674 PTR_ADD(rasBase, rasScan);
675 PTR_ADD(pMask, maskScan);
676 }
677 } else {
678 mlib_s32 dstA;
679 mlib_d64 cnstARGB;
680
681 if (dstF == 0xFF && srcF == 0) return;
682
683 cnstARGB = MUL8_VIS(cnstARGB0, srcF);
684 dstA = dstF + mul8_cnstA[srcF];
685
686 if (rasScan == 4*width) {
687 width *= height;
688 height = 1;
689 }
690
691 for (j = 0; j < height; j++) {
692 IntRgbAlphaMaskFill_A1_line(rasBase, pMask, width, cnstARGB,
693 dstF, dstA);
694
695 PTR_ADD(rasBase, rasScan);
696 }
697 }
698 }
699
700 /***************************************************************/
701
ADD_SUFF(ThreeByteBgrAlphaMaskFill)702 void ADD_SUFF(ThreeByteBgrAlphaMaskFill)(void *rasBase,
703 jubyte *pMask,
704 jint maskOff,
705 jint maskScan,
706 jint width,
707 jint height,
708 jint fgColor,
709 SurfaceDataRasInfo *pRasInfo,
710 NativePrimitive *pPrim,
711 CompositeInfo *pCompInfo)
712 {
713 mlib_d64 buff[BUFF_SIZE/2];
714 void *pbuff = buff;
715 mlib_s32 cnstA, cnstR, cnstG, cnstB;
716 mlib_s32 rasScan = pRasInfo->scanStride;
717 mlib_f32 cnstARGB0;
718 mlib_u8 *mul8_cnstA, *mul8_dstF, *mul8_srcF;
719 mlib_s32 SrcOpAnd, SrcOpXor, SrcOpAdd;
720 mlib_s32 DstOpAnd, DstOpXor, DstOpAdd;
721 mlib_s32 srcF, dstF;
722 mlib_s32 log_val[3];
723 mlib_s32 j;
724
725 if (width > BUFF_SIZE) pbuff = mlib_malloc(width*sizeof(mlib_s32));
726
727 cnstA = (fgColor >> 24) & 0xff;
728 cnstR = (fgColor >> 16) & 0xff;
729 cnstG = (fgColor >> 8) & 0xff;
730 cnstB = (fgColor ) & 0xff;
731
732 if (cnstA != 0xff) {
733 cnstR = mul8table[cnstA][cnstR];
734 cnstG = mul8table[cnstA][cnstG];
735 cnstB = mul8table[cnstA][cnstB];
736 }
737
738 cnstARGB0 = F32_FROM_U8x4(cnstA, cnstR, cnstG, cnstB);
739
740 SrcOpAnd = (AlphaRules[pCompInfo->rule].srcOps).andval;
741 SrcOpXor = (AlphaRules[pCompInfo->rule].srcOps).xorval;
742 SrcOpAdd = (AlphaRules[pCompInfo->rule].srcOps).addval;
743 SrcOpAdd -= SrcOpXor;
744
745 log_val[0] = SrcOpAnd;
746 log_val[1] = SrcOpXor;
747 log_val[2] = SrcOpAdd;
748
749 DstOpAnd = (AlphaRules[pCompInfo->rule].dstOps).andval;
750 DstOpXor = (AlphaRules[pCompInfo->rule].dstOps).xorval;
751 DstOpAdd = (AlphaRules[pCompInfo->rule].dstOps).addval;
752 DstOpAdd -= DstOpXor;
753
754 dstF = (((cnstA) & DstOpAnd) ^ DstOpXor) + DstOpAdd;
755 srcF = ((( 255) & SrcOpAnd) ^ SrcOpXor) + SrcOpAdd;
756
757 vis_write_gsr(7 << 3);
758
759 mul8_cnstA = mul8table[cnstA];
760
761 if (pMask != NULL) {
762 pMask += maskOff;
763
764 mul8_dstF = mul8table[dstF];
765 mul8_srcF = mul8table[srcF];
766
767 for (j = 0; j < height; j++) {
768 ADD_SUFF(ThreeByteBgrToIntArgbConvert)(rasBase, pbuff, width, 1,
769 pRasInfo, pRasInfo,
770 pPrim, pCompInfo);
771
772 IntRgbAlphaMaskFill_line(pbuff, pMask, width, cnstARGB0,
773 mul8_cnstA, mul8_dstF, mul8_srcF,
774 (void*)mul8table);
775
776 IntArgbToThreeByteBgrConvert(pbuff, rasBase, width, 1,
777 pRasInfo, pRasInfo, pPrim, pCompInfo);
778
779 PTR_ADD(rasBase, rasScan);
780 PTR_ADD(pMask, maskScan);
781 }
782 } else {
783 mlib_s32 dstA;
784 mlib_d64 cnstARGB;
785
786 if (dstF == 0xFF && srcF == 0) return;
787
788 cnstARGB = MUL8_VIS(cnstARGB0, srcF);
789 dstA = dstF + mul8_cnstA[srcF];
790
791 for (j = 0; j < height; j++) {
792 ADD_SUFF(ThreeByteBgrToIntArgbConvert)(rasBase, pbuff, width, 1,
793 pRasInfo, pRasInfo,
794 pPrim, pCompInfo);
795
796 IntRgbAlphaMaskFill_A1_line(pbuff, pMask, width, cnstARGB,
797 dstF, dstA);
798
799 IntArgbToThreeByteBgrConvert(pbuff, rasBase, width, 1,
800 pRasInfo, pRasInfo, pPrim, pCompInfo);
801
802 PTR_ADD(rasBase, rasScan);
803 }
804 }
805
806 if (pbuff != buff) {
807 mlib_free(pbuff);
808 }
809 }
810
811 /***************************************************************/
812
813 #endif /* JAVA2D_NO_MLIB */
814