CoCalc -- vis_SrcMaskFill.c

GitHub Repository: PojavLauncherTeam/openjdk-multiarch-jdk8u
Path: blob/aarch64-shenandoah-jdk8u272-b10/jdk/src/solaris/native/sun/java2d/loops/vis_SrcMaskFill.c
³²²⁸⁸ views
1
/*
2
 * Copyright (c) 2003, 2010, 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
 * IntArgbSrcMaskFill()
34
 * FourByteAbgrSrcMaskFill()
35
 */
36

37
#define MASK_FILL(rr, pathA, dstA, dstARGB)         \
38
{                                                   \
39
    mlib_d64 t0, t1;                                \
40
                                                    \
41
    dstA = MUL8_INT(dstA, 0xff - pathA);            \
42
                                                    \
43
    t0 = MUL8_VIS(cnstARGB0, pathA);                \
44
    t1 = MUL8_VIS(dstARGB, dstA);                   \
45
    rr = vis_fpadd16(t0, t1);                       \
46
                                                    \
47
    dstA = dstA + mul8_cnstA[pathA];                \
48
    DIV_ALPHA(rr, dstA);                            \
49
}
50

51
/***************************************************************/
52

53
static void IntArgbSrcMaskFill_line(mlib_f32 *dst_ptr,
54
                                    mlib_u8  *pMask,
55
                                    mlib_s32 width,
56
                                    mlib_d64 fgARGB,
57
                                    mlib_f32 cnstARGB0,
58
                                    mlib_u8  *mul8_cnstA,
59
                                    mlib_u8  *mul8_tbl)
60
{
61
    mlib_s32 i, i0;
62
    mlib_s32 pathA0, pathA1, dstA0, dstA1, msk;
63
    mlib_d64 res0, res1, dstARGB;
64
    mlib_f32 dstARGB0;
65

66
    i = i0 = 0;
67

68
    if ((mlib_s32)dst_ptr & 7) {
69
        pathA0 = pMask[i];
70

71
        if (pathA0 == 0xff) {
72
            dst_ptr[i] = vis_read_hi(fgARGB);
73
        } else if (pathA0) {
74
            dstA0 = *(mlib_u8*)(dst_ptr + i);
75
            dstARGB0 = dst_ptr[i];
76
            MASK_FILL(res0, pathA0, dstA0, dstARGB0);
77
            dst_ptr[i] = vis_fpack16(res0);
78
            *(mlib_u8*)(dst_ptr + i) = dstA0;
79
        }
80

81
        i0 = 1;
82
    }
83

84
#pragma pipeloop(0)
85
    for (i = i0; i <= width - 2; i += 2) {
86
        pathA0 = pMask[i];
87
        pathA1 = pMask[i + 1];
88
        dstA0 = *(mlib_u8*)(dst_ptr + i);
89
        dstA1 = *(mlib_u8*)(dst_ptr + i + 1);
90
        dstARGB = *(mlib_d64*)(dst_ptr + i);
91

92
        MASK_FILL(res0, pathA0, dstA0, vis_read_hi(dstARGB));
93
        MASK_FILL(res1, pathA1, dstA1, vis_read_lo(dstARGB));
94

95
        res0 = vis_fpack16_pair(res0, res1);
96

97
        msk = (((-pathA0) & (1 << 11)) | ((-pathA1) & (1 << 10))) >> 10;
98
        vis_pst_32(res0, dst_ptr + i, msk);
99

100
        *(mlib_u8*)(dst_ptr + i    ) = dstA0;
101
        *(mlib_u8*)(dst_ptr + i + 1) = dstA1;
102

103
        msk = (((254 - pathA0) & (1 << 11)) |
104
               ((254 - pathA1) & (1 << 10))) >> 10;
105
        vis_pst_32(fgARGB, dst_ptr + i, msk);
106
    }
107

108
    if (i < width) {
109
        pathA0 = pMask[i];
110

111
        if (pathA0 == 0xff) {
112
            dst_ptr[i] = vis_read_hi(fgARGB);
113
        } else if (pathA0) {
114
            dstA0 = *(mlib_u8*)(dst_ptr + i);
115
            dstARGB0 = dst_ptr[i];
116
            MASK_FILL(res0, pathA0, dstA0, dstARGB0);
117
            dst_ptr[i] = vis_fpack16(res0);
118
            *(mlib_u8*)(dst_ptr + i) = dstA0;
119
        }
120
    }
121
}
122

123
/***************************************************************/
124

125
void ADD_SUFF(IntArgbSrcMaskFill)(void *rasBase,
126
                                  jubyte *pMask,
127
                                  jint maskOff,
128
                                  jint maskScan,
129
                                  jint width,
130
                                  jint height,
131
                                  jint fgColor,
132
                                  SurfaceDataRasInfo *pRasInfo,
133
                                  NativePrimitive *pPrim,
134
                                  CompositeInfo *pCompInfo)
135
{
136
    mlib_s32 cnstA, cnstR, cnstG, cnstB;
137
    mlib_s32 rasScan = pRasInfo->scanStride;
138
    mlib_f32 cnstARGB0;
139
    mlib_d64 fgARGB;
140
    mlib_u8  *mul8_cnstA;
141
    mlib_s32 j;
142

143
    cnstA = (fgColor >> 24) & 0xff;
144
    cnstR = (fgColor >> 16) & 0xff;
145
    cnstG = (fgColor >>  8) & 0xff;
146
    cnstB = (fgColor      ) & 0xff;
147

148
    if (cnstA == 0) {
149
        fgColor = 0;
150
    }
151

152
    if (pMask == NULL) {
153
        void *pBase = pRasInfo->rasBase;
154
        pRasInfo->rasBase = rasBase;
155
        ADD_SUFF(AnyIntSetRect)(pRasInfo,
156
                                0, 0, width, height,
157
                                fgColor, pPrim, pCompInfo);
158
        pRasInfo->rasBase = pBase;
159
        return;
160
    }
161

162
    mul8_cnstA = mul8table[cnstA];
163
    if (cnstA != 0xff) {
164
        cnstR = mul8_cnstA[cnstR];
165
        cnstG = mul8_cnstA[cnstG];
166
        cnstB = mul8_cnstA[cnstB];
167
    }
168

169
    cnstARGB0 = F32_FROM_U8x4(cnstA, cnstR, cnstG, cnstB);
170

171
    fgARGB = vis_to_double_dup(fgColor);
172

173
    pMask += maskOff;
174

175
    if (rasScan == 4*width && maskScan == width) {
176
        width *= height;
177
        height = 1;
178
    }
179

180
    vis_write_gsr(7 << 3);
181

182
    for (j = 0; j < height; j++) {
183
        IntArgbSrcMaskFill_line(rasBase, pMask, width, fgARGB, cnstARGB0,
184
                                mul8_cnstA, (void*)mul8table);
185

186
        PTR_ADD(rasBase, rasScan);
187
        PTR_ADD(pMask, maskScan);
188
    }
189
}
190

191
/***************************************************************/
192

193
void ADD_SUFF(FourByteAbgrSrcMaskFill)(void *rasBase,
194
                                       jubyte *pMask,
195
                                       jint maskOff,
196
                                       jint maskScan,
197
                                       jint width,
198
                                       jint height,
199
                                       jint fgColor,
200
                                       SurfaceDataRasInfo *pRasInfo,
201
                                       NativePrimitive *pPrim,
202
                                       CompositeInfo *pCompInfo)
203
{
204
    mlib_d64 buff[BUFF_SIZE/2];
205
    void     *pbuff = buff;
206
    mlib_s32 cnstA, cnstR, cnstG, cnstB;
207
    mlib_s32 rasScan = pRasInfo->scanStride;
208
    mlib_f32 cnstARGB0;
209
    mlib_d64 fgARGB;
210
    mlib_u8  *mul8_cnstA;
211
    mlib_s32 j;
212

213
    cnstA = (mlib_u32)fgColor >> 24;
214
    cnstR = (fgColor >> 16) & 0xff;
215
    cnstG = (fgColor >>  8) & 0xff;
216
    cnstB = (fgColor      ) & 0xff;
217

218
    if (pMask == NULL) {
219
        void *pBase = pRasInfo->rasBase;
220
        pRasInfo->rasBase = rasBase;
221
        if (cnstA == 0) {
222
            fgColor = 0;
223
        } else {
224
            fgColor = (fgColor << 8) | cnstA;
225
        }
226
        ADD_SUFF(Any4ByteSetRect)(pRasInfo,
227
                                  0, 0, width, height,
228
                                  fgColor, pPrim, pCompInfo);
229
        pRasInfo->rasBase = pBase;
230
        return;
231
    }
232

233
    mul8_cnstA = mul8table[cnstA];
234

235
    if (cnstA == 0) {
236
        fgColor = 0;
237
        cnstR = cnstG = cnstB = 0;
238
    } else {
239
        fgColor = (cnstA << 24) | (cnstB << 16) | (cnstG << 8) | cnstR;
240
        if (cnstA != 0xff) {
241
            cnstR = mul8_cnstA[cnstR];
242
            cnstG = mul8_cnstA[cnstG];
243
            cnstB = mul8_cnstA[cnstB];
244
        }
245
    }
246

247
    cnstARGB0 = F32_FROM_U8x4(cnstA, cnstB, cnstG, cnstR);
248

249
    fgARGB = vis_to_double_dup(fgColor);
250

251
    pMask += maskOff;
252

253
    if (((mlib_s32)rasBase | rasScan) & 3) {
254
        if (width > BUFF_SIZE) pbuff = mlib_malloc(width*sizeof(mlib_s32));
255
    } else {
256
        if (rasScan == 4*width && maskScan == width) {
257
            width *= height;
258
            height = 1;
259
        }
260
    }
261

262
    vis_write_gsr(7 << 3);
263

264
    for (j = 0; j < height; j++) {
265
        if (!((mlib_s32)rasBase & 3)) {
266
            IntArgbSrcMaskFill_line(rasBase, pMask, width, fgARGB, cnstARGB0,
267
                                    mul8_cnstA, (void*)mul8table);
268
        } else {
269
            mlib_ImageCopy_na(rasBase, pbuff, width*sizeof(mlib_s32));
270
            IntArgbSrcMaskFill_line(pbuff, pMask, width, fgARGB, cnstARGB0,
271
                                    mul8_cnstA, (void*)mul8table);
272
            mlib_ImageCopy_na(pbuff, rasBase, width*sizeof(mlib_s32));
273
        }
274

275
        PTR_ADD(rasBase, rasScan);
276
        PTR_ADD(pMask, maskScan);
277
    }
278

279
    if (pbuff != buff) {
280
        mlib_free(pbuff);
281
    }
282
}
283

284
/***************************************************************/
285

286
/* ##############################################################
287
 * IntRgbSrcMaskFill()
288
 * IntBgrSrcMaskFill()
289
 */
290

291
#undef  MASK_FILL
292
#define MASK_FILL(rr, pathA, dstA, dstARGB)         \
293
{                                                   \
294
    mlib_d64 t0, t1;                                \
295
                                                    \
296
    dstA = 0xff - pathA;                            \
297
                                                    \
298
    t0 = MUL8_VIS(cnstARGB0, pathA);                \
299
    t1 = MUL8_VIS(dstARGB, dstA);                   \
300
    rr = vis_fpadd16(t0, t1);                       \
301
                                                    \
302
    dstA = dstA + mul8_cnstA[pathA];                \
303
    DIV_ALPHA_RGB(rr, dstA);                        \
304
}
305

306
/***************************************************************/
307

308
static void IntRgbSrcMaskFill_line(mlib_f32 *dst_ptr,
309
                                   mlib_u8  *pMask,
310
                                   mlib_s32 width,
311
                                   mlib_d64 fgARGB,
312
                                   mlib_f32 cnstARGB0,
313
                                   mlib_u8  *mul8_cnstA,
314
                                   mlib_u8  *mul8_tbl)
315
{
316
    mlib_s32 i, i0;
317
    mlib_s32 pathA0, pathA1, dstA0, dstA1, msk;
318
    mlib_d64 res0, res1, dstARGB;
319
    mlib_f32 dstARGB0;
320

321
    i = i0 = 0;
322

323
    if ((mlib_s32)dst_ptr & 7) {
324
        pathA0 = pMask[i];
325

326
        if (pathA0 == 0xff) {
327
            dst_ptr[i] = vis_read_hi(fgARGB);
328
        } else if (pathA0) {
329
            dstARGB0 = dst_ptr[i];
330
            MASK_FILL(res0, pathA0, dstA0, dstARGB0);
331
            dst_ptr[i] = vis_fpack16(res0);
332
        }
333

334
        i0 = 1;
335
    }
336

337
#pragma pipeloop(0)
338
    for (i = i0; i <= width - 2; i += 2) {
339
        pathA0 = pMask[i];
340
        pathA1 = pMask[i + 1];
341
        dstARGB = *(mlib_d64*)(dst_ptr + i);
342

343
        MASK_FILL(res0, pathA0, dstA0, vis_read_hi(dstARGB));
344
        MASK_FILL(res1, pathA1, dstA1, vis_read_lo(dstARGB));
345

346
        res0 = vis_fpack16_pair(res0, res1);
347

348
        msk = (((-pathA0) & (1 << 11)) | ((-pathA1) & (1 << 10))) >> 10;
349
        vis_pst_32(res0, dst_ptr + i, msk);
350

351
        msk = (((254 - pathA0) & (1 << 11)) |
352
               ((254 - pathA1) & (1 << 10))) >> 10;
353
        vis_pst_32(fgARGB, dst_ptr + i, msk);
354
    }
355

356
    if (i < width) {
357
        pathA0 = pMask[i];
358

359
        if (pathA0 == 0xff) {
360
            dst_ptr[i] = vis_read_hi(fgARGB);
361
        } else if (pathA0) {
362
            dstARGB0 = dst_ptr[i];
363
            MASK_FILL(res0, pathA0, dstA0, dstARGB0);
364
            dst_ptr[i] = vis_fpack16(res0);
365
        }
366
    }
367
}
368

369
/***************************************************************/
370

371
void ADD_SUFF(IntRgbSrcMaskFill)(void *rasBase,
372
                                 jubyte *pMask,
373
                                 jint maskOff,
374
                                 jint maskScan,
375
                                 jint width,
376
                                 jint height,
377
                                 jint fgColor,
378
                                 SurfaceDataRasInfo *pRasInfo,
379
                                 NativePrimitive *pPrim,
380
                                 CompositeInfo *pCompInfo)
381
{
382
    mlib_s32 cnstA, cnstR, cnstG, cnstB;
383
    mlib_s32 rasScan = pRasInfo->scanStride;
384
    mlib_f32 cnstARGB0;
385
    mlib_d64 fgARGB;
386
    mlib_u8  *mul8_cnstA;
387
    mlib_s32 j;
388

389
    cnstA = (fgColor >> 24) & 0xff;
390
    cnstR = (fgColor >> 16) & 0xff;
391
    cnstG = (fgColor >>  8) & 0xff;
392
    cnstB = (fgColor      ) & 0xff;
393

394
    if (cnstA == 0) fgColor = 0;
395

396
    if (pMask == NULL) {
397
        void *pBase = pRasInfo->rasBase;
398
        pRasInfo->rasBase = rasBase;
399
        ADD_SUFF(AnyIntSetRect)(pRasInfo,
400
                                0, 0, width, height,
401
                                fgColor, pPrim, pCompInfo);
402
        pRasInfo->rasBase = pBase;
403
        return;
404
    }
405

406
    mul8_cnstA = mul8table[cnstA];
407
    if (cnstA != 0xff) {
408
        cnstR = mul8_cnstA[cnstR];
409
        cnstG = mul8_cnstA[cnstG];
410
        cnstB = mul8_cnstA[cnstB];
411
    }
412

413
    cnstARGB0 = F32_FROM_U8x4(cnstA, cnstR, cnstG, cnstB);
414

415
    fgARGB = vis_to_double_dup(fgColor);
416

417
    pMask += maskOff;
418

419
    if (rasScan == 4*width && maskScan == width) {
420
        width *= height;
421
        height = 1;
422
    }
423

424
    vis_write_gsr(7 << 3);
425

426
    for (j = 0; j < height; j++) {
427
        IntRgbSrcMaskFill_line(rasBase, pMask, width, fgARGB, cnstARGB0,
428
                               mul8_cnstA, (void*)mul8table);
429

430
        PTR_ADD(rasBase, rasScan);
431
        PTR_ADD(pMask, maskScan);
432
    }
433
}
434

435
/***************************************************************/
436

437
void ADD_SUFF(IntBgrSrcMaskFill)(void *rasBase,
438
                                 jubyte *pMask,
439
                                 jint maskOff,
440
                                 jint maskScan,
441
                                 jint width,
442
                                 jint height,
443
                                 jint fgColor,
444
                                 SurfaceDataRasInfo *pRasInfo,
445
                                 NativePrimitive *pPrim,
446
                                 CompositeInfo *pCompInfo)
447
{
448
    mlib_s32 cnstA, cnstR, cnstG, cnstB;
449
    mlib_s32 rasScan = pRasInfo->scanStride;
450
    mlib_f32 cnstARGB0;
451
    mlib_d64 fgARGB;
452
    mlib_u8  *mul8_cnstA;
453
    mlib_s32 j;
454

455
    cnstA = (fgColor >> 24) & 0xff;
456
    cnstR = (fgColor >> 16) & 0xff;
457
    cnstG = (fgColor >>  8) & 0xff;
458
    cnstB = (fgColor      ) & 0xff;
459

460
    if (cnstA == 0) {
461
        fgColor = 0;
462
    } else {
463
        fgColor = (cnstB << 16) | (cnstG << 8) | (cnstR);
464
    }
465

466
    if (pMask == NULL) {
467
        void *pBase = pRasInfo->rasBase;
468
        pRasInfo->rasBase = rasBase;
469
        ADD_SUFF(AnyIntSetRect)(pRasInfo,
470
                                0, 0, width, height,
471
                                fgColor, pPrim, pCompInfo);
472
        pRasInfo->rasBase = pBase;
473
        return;
474
    }
475

476
    mul8_cnstA = mul8table[cnstA];
477
    if (cnstA != 0xff) {
478
        cnstR = mul8_cnstA[cnstR];
479
        cnstG = mul8_cnstA[cnstG];
480
        cnstB = mul8_cnstA[cnstB];
481
    }
482

483
    cnstARGB0 = F32_FROM_U8x4(cnstA, cnstB, cnstG, cnstR);
484

485
    fgARGB = vis_to_double_dup(fgColor);
486

487
    pMask += maskOff;
488

489
    if (rasScan == 4*width && maskScan == width) {
490
        width *= height;
491
        height = 1;
492
    }
493

494
    vis_write_gsr(7 << 3);
495

496
    for (j = 0; j < height; j++) {
497
        IntRgbSrcMaskFill_line(rasBase, pMask, width, fgARGB, cnstARGB0,
498
                               mul8_cnstA, (void*)mul8table);
499

500
        PTR_ADD(rasBase, rasScan);
501
        PTR_ADD(pMask, maskScan);
502
    }
503
}
504

505
/***************************************************************/
506

507
void ADD_SUFF(ThreeByteBgrSrcMaskFill)(void *rasBase,
508
                                       jubyte *pMask,
509
                                       jint maskOff,
510
                                       jint maskScan,
511
                                       jint width,
512
                                       jint height,
513
                                       jint fgColor,
514
                                       SurfaceDataRasInfo *pRasInfo,
515
                                       NativePrimitive *pPrim,
516
                                       CompositeInfo *pCompInfo)
517
{
518
    mlib_d64 buff[BUFF_SIZE/2];
519
    void     *pbuff = buff;
520
    mlib_s32 cnstA, cnstR, cnstG, cnstB;
521
    mlib_s32 rasScan = pRasInfo->scanStride;
522
    mlib_f32 cnstARGB0;
523
    mlib_d64 fgARGB;
524
    mlib_u8  *mul8_cnstA;
525
    mlib_s32 j;
526

527
    cnstA = (fgColor >> 24) & 0xff;
528
    cnstR = (fgColor >> 16) & 0xff;
529
    cnstG = (fgColor >>  8) & 0xff;
530
    cnstB = (fgColor      ) & 0xff;
531

532
    if (cnstA == 0) {
533
        fgColor = 0;
534
    }
535

536
    if (pMask == NULL) {
537
        void *pBase = pRasInfo->rasBase;
538
        pRasInfo->rasBase = rasBase;
539
        ADD_SUFF(Any3ByteSetRect)(pRasInfo,
540
                                  0, 0, width, height,
541
                                  fgColor, pPrim, pCompInfo);
542
        pRasInfo->rasBase = pBase;
543
        return;
544
    }
545

546
    mul8_cnstA = mul8table[cnstA];
547
    if (cnstA != 0xff) {
548
        cnstR = mul8_cnstA[cnstR];
549
        cnstG = mul8_cnstA[cnstG];
550
        cnstB = mul8_cnstA[cnstB];
551
    }
552

553
    cnstARGB0 = F32_FROM_U8x4(cnstA, cnstR, cnstG, cnstB);
554

555
    fgARGB = vis_to_double_dup(fgColor);
556

557
    pMask += maskOff;
558

559
    if (width > BUFF_SIZE) pbuff = mlib_malloc(width*sizeof(mlib_s32));
560

561
    vis_write_gsr(7 << 3);
562

563
    for (j = 0; j < height; j++) {
564
        ADD_SUFF(ThreeByteBgrToIntArgbConvert)(rasBase, pbuff, width, 1,
565
                                               pRasInfo, pRasInfo,
566
                                               pPrim, pCompInfo);
567

568
        IntRgbSrcMaskFill_line(pbuff, pMask, width, fgARGB, cnstARGB0,
569
                               mul8_cnstA, (void*)mul8table);
570

571
        IntArgbToThreeByteBgrConvert(pbuff, rasBase, width, 1,
572
                                     pRasInfo, pRasInfo, pPrim, pCompInfo);
573

574
        PTR_ADD(rasBase, rasScan);
575
        PTR_ADD(pMask, maskScan);
576
    }
577

578
    if (pbuff != buff) {
579
        mlib_free(pbuff);
580
    }
581
}
582

583
/***************************************************************/
584

585
#endif
586

587
Product

Resources

Company
