CoCalc -- vis_IntBgr.c

GitHub Repository: PojavLauncherTeam/openjdk-multiarch-jdk8u
Path: blob/aarch64-shenandoah-jdk8u272-b10/jdk/src/solaris/native/sun/java2d/loops/vis_IntBgr.c
³²²⁸⁸ views
1
/*
2
 * Copyright (c) 2003, 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
#define ARGB_to_GBGR(x)        \
33
    (x << 16) | (x & 0xff00) | ((x >> 16) & 0xff)
34

35
/***************************************************************/
36

37
#define ARGB_to_BGR(x)         \
38
    ((x << 16) & 0xff0000) | (x & 0xff00) | ((x >> 16) & 0xff)
39

40
/***************************************************************/
41

42
#define READ_Bgr(i)    \
43
    (src[3*i] << 16) | (src[3*i + 1] << 8) | src[3*i + 2]
44

45
/***************************************************************/
46

47
#define ARGB_to_GBGR_FL2(dst, src0, src1) {                    \
48
    mlib_d64 t0, t1, t2;                                       \
49
    t0 = vis_fpmerge(src0, src1);                              \
50
    t1 = vis_fpmerge(vis_read_lo(t0), vis_read_hi(t0));        \
51
    t2 = vis_fpmerge(vis_read_lo(t0), vis_read_lo(t0));        \
52
    dst = vis_fpmerge(vis_read_hi(t2), vis_read_lo(t1));       \
53
}
54

55
/***************************************************************/
56

57
#define ARGB_to_BGR_FL2(dst, src0, src1) {                     \
58
    mlib_d64 t0, t1, t2;                                       \
59
    t0 = vis_fpmerge(src0, src1);                              \
60
    t1 = vis_fpmerge(vis_read_lo(t0), vis_read_hi(t0));        \
61
    t2 = vis_fpmerge(vis_fzeros(),    vis_read_lo(t0));        \
62
    dst = vis_fpmerge(vis_read_hi(t2), vis_read_lo(t1));       \
63
}
64

65
/***************************************************************/
66

67
void ADD_SUFF(IntBgrToIntArgbConvert)(BLIT_PARAMS)
68
{
69
    mlib_s32 dstScan = pDstInfo->scanStride;
70
    mlib_s32 srcScan = pSrcInfo->scanStride;
71
    mlib_d64 dd, amask;
72
    mlib_s32 i, i0, j, x;
73

74
    if (dstScan == 4*width && srcScan == 4*width) {
75
        width *= height;
76
        height = 1;
77
    }
78

79
    amask = vis_to_double_dup(0xFF000000);
80
    vis_alignaddr(NULL, 7);
81

82
    for (j = 0; j < height; j++) {
83
        mlib_u32 *src = srcBase;
84
        mlib_u32 *dst = dstBase;
85

86
        i = i0 = 0;
87

88
        if ((mlib_s32)dst & 7) {
89
            x = src[i];
90
            dst[i] = 0xff000000 | ARGB_to_GBGR(x);
91
            i0 = 1;
92
        }
93

94
#pragma pipeloop(0)
95
        for (i = i0; i <= (mlib_s32)width - 2; i += 2) {
96
            ARGB2ABGR_FL2(dd, ((mlib_f32*)src)[i], ((mlib_f32*)src)[i + 1]);
97
            *(mlib_d64*)(dst + i) = vis_for(dd, amask);
98
        }
99

100
        if (i < width) {
101
            x = src[i];
102
            dst[i] = 0xff000000 | ARGB_to_GBGR(x);
103
        }
104

105
        PTR_ADD(dstBase, dstScan);
106
        PTR_ADD(srcBase, srcScan);
107
    }
108
}
109

110
/***************************************************************/
111

112
void ADD_SUFF(IntBgrToIntArgbScaleConvert)(SCALE_PARAMS)
113
{
114
    mlib_s32 dstScan = pDstInfo->scanStride;
115
    mlib_s32 srcScan = pSrcInfo->scanStride;
116
    mlib_d64 dd, amask;
117
    mlib_s32 j, x;
118

119
    amask = vis_to_double_dup(0xFF000000);
120
    vis_alignaddr(NULL, 7);
121

122
    for (j = 0; j < height; j++) {
123
        mlib_u32 *src = srcBase;
124
        mlib_u32 *dst = dstBase;
125
        mlib_u32 *dst_end = dst + width;
126
        mlib_s32 tmpsxloc = sxloc;
127

128
        PTR_ADD(src, (syloc >> shift) * srcScan);
129

130
        if ((mlib_s32)dst & 7) {
131
            x = src[tmpsxloc >> shift];
132
            *dst++ = 0xff000000 | ARGB_to_GBGR(x);
133
            tmpsxloc += sxinc;
134
        }
135

136
#pragma pipeloop(0)
137
        for (; dst <= dst_end - 2; dst += 2) {
138
            ARGB2ABGR_FL2(dd, ((mlib_f32*)src)[tmpsxloc >> shift],
139
                              ((mlib_f32*)src)[(tmpsxloc + sxinc) >> shift]);
140
            *(mlib_d64*)dst = vis_for(dd, amask);
141
            tmpsxloc += 2*sxinc;
142
        }
143

144
        for (; dst < dst_end; dst++) {
145
            x = src[tmpsxloc >> shift];
146
            *dst++ = 0xff000000 | ARGB_to_GBGR(x);
147
            tmpsxloc += sxinc;
148
        }
149

150
        PTR_ADD(dstBase, dstScan);
151
        syloc += syinc;
152
    }
153
}
154

155
/***************************************************************/
156

157
void ADD_SUFF(IntArgbToIntBgrConvert)(BLIT_PARAMS)
158
{
159
    mlib_s32 dstScan = pDstInfo->scanStride;
160
    mlib_s32 srcScan = pSrcInfo->scanStride;
161
    mlib_d64 dd;
162
    mlib_s32 i, i0, j, x;
163

164
    if (dstScan == 4*width && srcScan == 4*width) {
165
        width *= height;
166
        height = 1;
167
    }
168

169
    for (j = 0; j < height; j++) {
170
        mlib_u32 *src = srcBase;
171
        mlib_u32 *dst = dstBase;
172

173
        i = i0 = 0;
174

175
        if ((mlib_s32)dst & 7) {
176
            x = src[i];
177
            dst[i] = ARGB_to_GBGR(x);
178
            i0 = 1;
179
        }
180

181
#pragma pipeloop(0)
182
        for (i = i0; i <= (mlib_s32)width - 2; i += 2) {
183
            ARGB_to_GBGR_FL2(dd, ((mlib_f32*)src)[i], ((mlib_f32*)src)[i + 1]);
184
            *(mlib_d64*)(dst + i) = dd;
185
        }
186

187
        if (i < width) {
188
            x = src[i];
189
            dst[i] = ARGB_to_GBGR(x);
190
        }
191

192
        PTR_ADD(dstBase, dstScan);
193
        PTR_ADD(srcBase, srcScan);
194
    }
195
}
196

197
/***************************************************************/
198

199
void ADD_SUFF(IntArgbToIntBgrScaleConvert)(SCALE_PARAMS)
200
{
201
    mlib_s32 dstScan = pDstInfo->scanStride;
202
    mlib_s32 srcScan = pSrcInfo->scanStride;
203
    mlib_d64 dd;
204
    mlib_s32 j, x;
205

206
    for (j = 0; j < height; j++) {
207
        mlib_u32 *src = srcBase;
208
        mlib_u32 *dst = dstBase;
209
        mlib_u32 *dst_end = dst + width;
210
        mlib_s32 tmpsxloc = sxloc;
211

212
        PTR_ADD(src, (syloc >> shift) * srcScan);
213

214
        if ((mlib_s32)dst & 7) {
215
            x = src[tmpsxloc >> shift];
216
            *dst++ = ARGB_to_GBGR(x);
217
            tmpsxloc += sxinc;
218
        }
219

220
#pragma pipeloop(0)
221
        for (; dst <= dst_end - 2; dst += 2) {
222
            ARGB_to_GBGR_FL2(dd, ((mlib_f32*)src)[tmpsxloc >> shift],
223
                                 ((mlib_f32*)src)[(tmpsxloc + sxinc) >> shift]);
224
            *(mlib_d64*)dst = dd;
225
            tmpsxloc += 2*sxinc;
226
        }
227

228
        for (; dst < dst_end; dst++) {
229
            x = src[tmpsxloc >> shift];
230
            *dst++ = ARGB_to_GBGR(x);
231
            tmpsxloc += sxinc;
232
        }
233

234
        PTR_ADD(dstBase, dstScan);
235
        syloc += syinc;
236
    }
237
}
238

239
/***************************************************************/
240

241
#define INSERT_U8_34R {                                        \
242
    mlib_d64 sda, sdb, sdc, sdd;                               \
243
    mlib_d64 sde, sdf, sdg, sdh;                               \
244
    mlib_d64 sdi, sdj, sdk, sdl;                               \
245
    mlib_d64 sdm;                                              \
246
                                                               \
247
    sda = vis_fpmerge(vis_read_hi(sd0), vis_read_lo(sd1));     \
248
    sdb = vis_fpmerge(vis_read_lo(sd0), vis_read_hi(sd2));     \
249
    sdc = vis_fpmerge(vis_read_hi(sd1), vis_read_lo(sd2));     \
250
    sdd = vis_fpmerge(vis_read_hi(sda), vis_read_lo(sdb));     \
251
    sde = vis_fpmerge(vis_read_lo(sda), vis_read_hi(sdc));     \
252
    sdf = vis_fpmerge(vis_read_hi(sdb), vis_read_lo(sdc));     \
253
    sdg = vis_fpmerge(vis_read_hi(sdd), vis_read_lo(sde));     \
254
    sdh = vis_fpmerge(vis_read_lo(sdd), vis_read_hi(sdf));     \
255
    sdi = vis_fpmerge(vis_read_hi(sde), vis_read_lo(sdf));     \
256
    sdj = vis_fpmerge(vis_read_hi(sdg), vis_read_hi(sdi));     \
257
    sdk = vis_fpmerge(vis_read_lo(sdg), vis_read_lo(sdi));     \
258
    sdl = vis_fpmerge(vis_read_hi(sFF), vis_read_hi(sdh));     \
259
    sdm = vis_fpmerge(vis_read_lo(sFF), vis_read_lo(sdh));     \
260
    dd0 = vis_fpmerge(vis_read_hi(sdl), vis_read_hi(sdj));     \
261
    dd1 = vis_fpmerge(vis_read_lo(sdl), vis_read_lo(sdj));     \
262
    dd2 = vis_fpmerge(vis_read_hi(sdm), vis_read_hi(sdk));     \
263
    dd3 = vis_fpmerge(vis_read_lo(sdm), vis_read_lo(sdk));     \
264
}
265

266
/***************************************************************/
267

268
void ADD_SUFF(ThreeByteBgrToIntBgrConvert)(BLIT_PARAMS)
269
{
270
    mlib_s32 dstScan = pDstInfo->scanStride;
271
    mlib_s32 srcScan = pSrcInfo->scanStride;
272
    mlib_d64 *sp;
273
    mlib_d64 sFF;
274
    mlib_d64 s0, s1, s2, s3, sd0, sd1, sd2, dd0, dd1, dd2, dd3;
275
    mlib_s32 i, i0, j;
276

277
    if (width < 16) {
278
        for (j = 0; j < height; j++) {
279
            mlib_u8  *src = srcBase;
280
            mlib_u32 *dst = dstBase;
281

282
            for (i = 0; i < width; i++) {
283
                dst[i] = READ_Bgr(i);
284
            }
285

286
            PTR_ADD(dstBase, dstScan);
287
            PTR_ADD(srcBase, srcScan);
288
        }
289
        return;
290
    }
291

292
    if (srcScan == 3*width && dstScan == 4*width) {
293
        width *= height;
294
        height = 1;
295
    }
296

297
    sFF = vis_fzero();
298

299
    for (j = 0; j < height; j++) {
300
        mlib_u8  *src = srcBase;
301
        mlib_f32 *dst = dstBase;
302

303
        i = i0 = 0;
304

305
        if ((mlib_s32)dst & 7) {
306
            ((mlib_s32*)dst)[i] = READ_Bgr(i);
307
            i0 = 1;
308
        }
309

310
        sp = vis_alignaddr(src, 3*i0);
311
        s3 = *sp++;
312

313
#pragma pipeloop(0)
314
        for (i = i0; i <= (mlib_s32)width - 8; i += 8) {
315
            s0 = s3;
316
            s1 = *sp++;
317
            s2 = *sp++;
318
            s3 = *sp++;
319
            sd0 = vis_faligndata(s0, s1);
320
            sd1 = vis_faligndata(s1, s2);
321
            sd2 = vis_faligndata(s2, s3);
322

323
            INSERT_U8_34R
324

325
            *(mlib_d64*)(dst + i    ) = dd0;
326
            *(mlib_d64*)(dst + i + 2) = dd1;
327
            *(mlib_d64*)(dst + i + 4) = dd2;
328
            *(mlib_d64*)(dst + i + 6) = dd3;
329
        }
330

331
        for (; i < width; i++) {
332
            ((mlib_s32*)dst)[i] = READ_Bgr(i);
333
        }
334

335
        PTR_ADD(dstBase, dstScan);
336
        PTR_ADD(srcBase, srcScan);
337
    }
338
}
339

340
/***************************************************************/
341

342
void ADD_SUFF(ThreeByteBgrToIntBgrScaleConvert)(SCALE_PARAMS)
343
{
344
    mlib_s32 dstScan = pDstInfo->scanStride;
345
    mlib_s32 srcScan = pSrcInfo->scanStride;
346
    mlib_d64 dd, dzero;
347
    mlib_s32 i, i0, i1, j;
348

349
    if (width < 16) {
350
        for (j = 0; j < height; j++) {
351
            mlib_u8  *src = srcBase;
352
            mlib_s32 *dst = dstBase;
353
            mlib_s32 *dst_end = dst + width;
354
            mlib_s32 tmpsxloc = sxloc;
355

356
            PTR_ADD(src, (syloc >> shift) * srcScan);
357

358
            for (; dst < dst_end; dst++) {
359
                i = tmpsxloc >> shift;
360
                tmpsxloc += sxinc;
361
                *(mlib_s32*)dst = READ_Bgr(i);
362
            }
363

364
            PTR_ADD(dstBase, dstScan);
365
            syloc += syinc;
366
        }
367
        return;
368
    }
369

370
    dzero = vis_fzero();
371

372
    vis_alignaddr(NULL, 7);
373

374
    for (j = 0; j < height; j++) {
375
        mlib_u8  *src = srcBase;
376
        mlib_f32 *dst = dstBase;
377
        mlib_f32 *dst_end = dst + width;
378
        mlib_s32 tmpsxloc = sxloc;
379

380
        PTR_ADD(src, (syloc >> shift) * srcScan);
381

382
        if ((mlib_s32)dst & 7) {
383
            i = tmpsxloc >> shift;
384
            tmpsxloc += sxinc;
385
            *(mlib_s32*)dst = READ_Bgr(i);
386
            dst++;
387
        }
388

389
#pragma pipeloop(0)
390
        for (; dst <= dst_end - 2; dst += 2) {
391
            i0 = tmpsxloc >> shift;
392
            i1 = (tmpsxloc + sxinc) >> shift;
393
            tmpsxloc += 2*sxinc;
394

395
            dd = vis_faligndata(vis_ld_u8(src + 3*i1 + 2), dd);
396
            dd = vis_faligndata(vis_ld_u8(src + 3*i1 + 1), dd);
397
            dd = vis_faligndata(vis_ld_u8(src + 3*i1    ), dd);
398
            dd = vis_faligndata(dzero, dd);
399
            dd = vis_faligndata(vis_ld_u8(src + 3*i0 + 2), dd);
400
            dd = vis_faligndata(vis_ld_u8(src + 3*i0 + 1), dd);
401
            dd = vis_faligndata(vis_ld_u8(src + 3*i0    ), dd);
402
            dd = vis_faligndata(dzero, dd);
403

404
            *(mlib_d64*)dst = dd;
405
        }
406

407
        for (; dst < dst_end; dst++) {
408
            i = tmpsxloc >> shift;
409
            tmpsxloc += sxinc;
410
            *(mlib_s32*)dst = READ_Bgr(i);
411
        }
412

413
        PTR_ADD(dstBase, dstScan);
414
        syloc += syinc;
415
    }
416
}
417

418
/***************************************************************/
419

420
void ADD_SUFF(IntArgbBmToIntBgrXparOver)(BLIT_PARAMS)
421
{
422
    mlib_s32 dstScan = pDstInfo->scanStride;
423
    mlib_s32 srcScan = pSrcInfo->scanStride;
424
    mlib_d64 dd;
425
    mlib_s32 i, i0, j, mask, x;
426

427
    if (dstScan == 4*width && srcScan == 4*width) {
428
        width *= height;
429
        height = 1;
430
    }
431

432
    for (j = 0; j < height; j++) {
433
        mlib_s32 *src = srcBase;
434
        mlib_s32 *dst = dstBase;
435

436
        i = i0 = 0;
437

438
        if ((mlib_s32)dst & 7) {
439
            if (*(mlib_u8*)(src + i)) {
440
                x = src[i];
441
                dst[i] = ARGB_to_GBGR(x);
442
            }
443
            i0 = 1;
444
        }
445

446
#pragma pipeloop(0)
447
        for (i = i0; i <= (mlib_s32)width - 2; i += 2) {
448
            ARGB_to_GBGR_FL2(dd, ((mlib_f32*)src)[i], ((mlib_f32*)src)[i + 1]);
449
            mask = (((-*(mlib_u8*)(src + i)) >> 31) & 2) |
450
                   (((-*(mlib_u8*)(src + i + 1)) >> 31) & 1);
451
            vis_pst_32(dd, dst + i, mask);
452
        }
453

454
        if (i < width) {
455
            if (*(mlib_u8*)(src + i)) {
456
                x = src[i];
457
                dst[i] = ARGB_to_GBGR(x);
458
            }
459
        }
460

461
        PTR_ADD(dstBase, dstScan);
462
        PTR_ADD(srcBase, srcScan);
463
    }
464
}
465

466
/***************************************************************/
467

468
void ADD_SUFF(IntArgbBmToIntBgrScaleXparOver)(SCALE_PARAMS)
469
{
470
    mlib_s32 dstScan = pDstInfo->scanStride;
471
    mlib_s32 srcScan = pSrcInfo->scanStride;
472
    mlib_d64 dd;
473
    mlib_s32 j, mask;
474

475
    for (j = 0; j < height; j++) {
476
        mlib_s32 *src = srcBase;
477
        mlib_s32 *dst = dstBase;
478
        mlib_s32 *dst_end = dst + width;
479
        mlib_s32 tmpsxloc = sxloc;
480

481
        PTR_ADD(src, (syloc >> shift) * srcScan);
482

483
        if ((mlib_s32)dst & 7) {
484
            mlib_s32 *pp = src + (tmpsxloc >> shift);
485
            if (*(mlib_u8*)pp) {
486
                *dst = ARGB_to_GBGR(*pp);
487
            }
488
            dst++;
489
            tmpsxloc += sxinc;
490
        }
491

492
#pragma pipeloop(0)
493
        for (; dst <= dst_end - 2; dst += 2) {
494
            mlib_s32 *pp0 = src + (tmpsxloc >> shift);
495
            mlib_s32 *pp1 = src + ((tmpsxloc + sxinc) >> shift);
496
            ARGB_to_GBGR_FL2(dd, *(mlib_f32*)pp0, *(mlib_f32*)pp1);
497
            mask = (((-*(mlib_u8*)pp0) >> 31) & 2) |
498
                   ((mlib_u32)(-*(mlib_u8*)pp1) >> 31);
499
            vis_pst_32(dd, dst, mask);
500
            tmpsxloc += 2*sxinc;
501
        }
502

503
        for (; dst < dst_end; dst++) {
504
            mlib_s32 *pp = src + (tmpsxloc >> shift);
505
            if (*(mlib_u8*)pp) {
506
                *dst = ARGB_to_GBGR(*pp);
507
            }
508
        }
509

510
        PTR_ADD(dstBase, dstScan);
511
        syloc += syinc;
512
    }
513
}
514

515
/***************************************************************/
516

517
void ADD_SUFF(IntArgbBmToIntBgrXparBgCopy)(BCOPY_PARAMS)
518
{
519
    mlib_s32 dstScan = pDstInfo->scanStride;
520
    mlib_s32 srcScan = pSrcInfo->scanStride;
521
    mlib_d64 dd, d_bgpixel;
522
    mlib_s32 i, i0, j, mask;
523

524
    if (dstScan == 4*width && srcScan == 4*width) {
525
        width *= height;
526
        height = 1;
527
    }
528

529
    vis_alignaddr(NULL, 1);
530
    d_bgpixel = vis_to_double_dup(bgpixel);
531

532
    for (j = 0; j < height; j++) {
533
        mlib_s32 *src = srcBase;
534
        mlib_s32 *dst = dstBase;
535

536
        i = i0 = 0;
537

538
        if ((mlib_s32)dst & 7) {
539
            if (*(mlib_u8*)(src + i)) {
540
                dst[i] = ARGB_to_GBGR(src[i]);
541
            } else {
542
                dst[i] = bgpixel;
543
            }
544
            i0 = 1;
545
        }
546

547
#pragma pipeloop(0)
548
        for (i = i0; i <= (mlib_s32)width - 2; i += 2) {
549
            ARGB_to_GBGR_FL2(dd, ((mlib_f32*)src)[i], ((mlib_f32*)src)[i + 1]);
550
            mask = (((-*(mlib_u8*)(src + i)) >> 31) & 2) |
551
                   (((-*(mlib_u8*)(src + i + 1)) >> 31) & 1);
552
            *(mlib_d64*)(dst + i) = d_bgpixel;
553
            vis_pst_32(dd, dst + i, mask);
554
        }
555

556
        if (i < width) {
557
            if (*(mlib_u8*)(src + i)) {
558
                dst[i] = ARGB_to_GBGR(src[i]);
559
            } else {
560
                dst[i] = bgpixel;
561
            }
562
        }
563

564
        PTR_ADD(dstBase, dstScan);
565
        PTR_ADD(srcBase, srcScan);
566
    }
567
}
568

569
/***************************************************************/
570

571
void ADD_SUFF(ByteIndexedToIntBgrConvert)(BLIT_PARAMS)
572
{
573
    jint *pixLut = pSrcInfo->lutBase;
574
    mlib_s32 dstScan = pDstInfo->scanStride;
575
    mlib_s32 srcScan = pSrcInfo->scanStride;
576
    mlib_d64 dd;
577
    mlib_s32 i, i0, j, x;
578

579
    if (srcScan == width && dstScan == 4*width) {
580
        width *= height;
581
        height = 1;
582
    }
583

584
    for (j = 0; j < height; j++) {
585
        mlib_u8  *src = srcBase;
586
        mlib_s32 *dst = dstBase;
587

588
        i = i0 = 0;
589

590
        if ((mlib_s32)dst & 7) {
591
            x = pixLut[src[i]];
592
            dst[i] = ARGB_to_GBGR(x);
593
            i0 = 1;
594
        }
595

596
#pragma pipeloop(0)
597
        for (i = i0; i <= (mlib_s32)width - 2; i += 2) {
598
            ARGB_to_GBGR_FL2(dd, ((mlib_f32*)pixLut)[src[i]],
599
                                 ((mlib_f32*)pixLut)[src[i + 1]]);
600
            *(mlib_d64*)(dst + i) = dd;
601
        }
602

603
        for (; i < width; i++) {
604
            x = pixLut[src[i]];
605
            dst[i] = ARGB_to_GBGR(x);
606
        }
607

608
        PTR_ADD(dstBase, dstScan);
609
        PTR_ADD(srcBase, srcScan);
610
    }
611
}
612

613
/***************************************************************/
614

615
void ADD_SUFF(ByteIndexedToIntBgrScaleConvert)(SCALE_PARAMS)
616
{
617
    jint *pixLut = pSrcInfo->lutBase;
618
    mlib_s32 dstScan = pDstInfo->scanStride;
619
    mlib_s32 srcScan = pSrcInfo->scanStride;
620
    mlib_d64 dd;
621
    mlib_s32 j, x;
622

623
    for (j = 0; j < height; j++) {
624
        mlib_u8  *src = srcBase;
625
        mlib_s32 *dst = dstBase;
626
        mlib_s32 *dst_end = dst + width;
627
        mlib_s32 tmpsxloc = sxloc;
628

629
        PTR_ADD(src, (syloc >> shift) * srcScan);
630

631
        if ((mlib_s32)dst & 7) {
632
            x = pixLut[src[tmpsxloc >> shift]];
633
            *dst++ = ARGB_to_GBGR(x);
634
            tmpsxloc += sxinc;
635
        }
636

637
#pragma pipeloop(0)
638
        for (; dst <= dst_end - 2; dst += 2) {
639
            mlib_f32 f0 = ((mlib_f32*)pixLut)[src[tmpsxloc >> shift]];
640
            mlib_f32 f1 = ((mlib_f32*)pixLut)[src[(tmpsxloc + sxinc) >> shift]];
641
            ARGB_to_GBGR_FL2(dd, f0, f1);
642
            *(mlib_d64*)dst = dd;
643
            tmpsxloc += 2*sxinc;
644
        }
645

646
        for (; dst < dst_end; dst++) {
647
            x = pixLut[src[tmpsxloc >> shift]];
648
            *dst++ = ARGB_to_GBGR(x);
649
            tmpsxloc += sxinc;
650
        }
651

652
        PTR_ADD(dstBase, dstScan);
653
        syloc += syinc;
654
    }
655
}
656

657
/***************************************************************/
658

659
void ADD_SUFF(ByteIndexedBmToIntBgrXparOver)(BLIT_PARAMS)
660
{
661
    jint *pixLut = pSrcInfo->lutBase;
662
    mlib_s32 dstScan = pDstInfo->scanStride;
663
    mlib_s32 srcScan = pSrcInfo->scanStride;
664
    mlib_d64 dd;
665
    mlib_s32 i, i0, j, x, mask;
666

667
    if (srcScan == width && dstScan == 4*width) {
668
        width *= height;
669
        height = 1;
670
    }
671

672
    for (j = 0; j < height; j++) {
673
        mlib_u8  *src = srcBase;
674
        mlib_s32 *dst = dstBase;
675

676
        i = i0 = 0;
677

678
        if ((mlib_s32)dst & 7) {
679
            x = pixLut[src[i]];
680
            if (x < 0) {
681
                dst[i] = ARGB_to_BGR(x);
682
            }
683
            i0 = 1;
684
        }
685

686
#pragma pipeloop(0)
687
        for (i = i0; i <= (mlib_s32)width - 2; i += 2) {
688
            mlib_f32 *pp0 = (mlib_f32*)pixLut + src[i];
689
            mlib_f32 *pp1 = (mlib_f32*)pixLut + src[i + 1];
690
            ARGB_to_BGR_FL2(dd, *pp0, *pp1);
691
            mask = (((*(mlib_u8*)pp0) >> 6) & 2) | ((*(mlib_u8*)pp1) >> 7);
692
            vis_pst_32(dd, dst + i, mask);
693
        }
694

695
        for (; i < width; i++) {
696
            x = pixLut[src[i]];
697
            if (x < 0) {
698
                dst[i] = ARGB_to_BGR(x);
699
            }
700
        }
701

702
        PTR_ADD(dstBase, dstScan);
703
        PTR_ADD(srcBase, srcScan);
704
    }
705
}
706

707
/***************************************************************/
708

709
void ADD_SUFF(ByteIndexedBmToIntBgrScaleXparOver)(SCALE_PARAMS)
710
{
711
    jint *pixLut = pSrcInfo->lutBase;
712
    mlib_s32 dstScan = pDstInfo->scanStride;
713
    mlib_s32 srcScan = pSrcInfo->scanStride;
714
    mlib_d64 dd;
715
    mlib_s32 j, x, mask;
716

717
    for (j = 0; j < height; j++) {
718
        mlib_u8  *src = srcBase;
719
        mlib_s32 *dst = dstBase;
720
        mlib_s32 *dst_end = dst + width;
721
        mlib_s32 tmpsxloc = sxloc;
722

723
        PTR_ADD(src, (syloc >> shift) * srcScan);
724

725
        if ((mlib_s32)dst & 7) {
726
            x = pixLut[src[tmpsxloc >> shift]];
727
            tmpsxloc += sxinc;
728
            if (x < 0) {
729
                *dst = ARGB_to_BGR(x);
730
            }
731
            dst++;
732
        }
733

734
#pragma pipeloop(0)
735
        for (; dst <= dst_end - 2; dst += 2) {
736
            mlib_f32 *p0 = (mlib_f32*)pixLut + src[tmpsxloc >> shift];
737
            mlib_f32 *p1 = (mlib_f32*)pixLut + src[(tmpsxloc + sxinc) >> shift];
738
            ARGB_to_BGR_FL2(dd, *p0, *p1);
739
            mask = (((*(mlib_u8*)p0) >> 6) & 2) | ((*(mlib_u8*)p1) >> 7);
740
            tmpsxloc += 2*sxinc;
741
            vis_pst_32(dd, dst, mask);
742
        }
743

744
        for (; dst < dst_end; dst++) {
745
            x = pixLut[src[tmpsxloc >> shift]];
746
            tmpsxloc += sxinc;
747
            if (x < 0) {
748
                *dst = ARGB_to_BGR(x);
749
            }
750
        }
751

752
        PTR_ADD(dstBase, dstScan);
753
        syloc += syinc;
754
    }
755
}
756

757
/***************************************************************/
758

759
void ADD_SUFF(ByteIndexedBmToIntBgrXparBgCopy)(BCOPY_PARAMS)
760
{
761
    jint *pixLut = pSrcInfo->lutBase;
762
    mlib_s32 dstScan = pDstInfo->scanStride;
763
    mlib_s32 srcScan = pSrcInfo->scanStride;
764
    mlib_d64 dd, d_bgpixel;
765
    mlib_s32 j, x, mask;
766

767
    if (srcScan == width && dstScan == 4*width) {
768
        width *= height;
769
        height = 1;
770
    }
771

772
    d_bgpixel = vis_to_double_dup(bgpixel);
773

774
    for (j = 0; j < height; j++) {
775
        mlib_u8  *src = srcBase;
776
        mlib_s32 *dst = dstBase;
777
        mlib_s32 *dst_end;
778

779
        dst_end = dst + width;
780

781
        if ((mlib_s32)dst & 7) {
782
            x = pixLut[*src++];
783
            if (x < 0) {
784
                *dst = ARGB_to_GBGR(x);
785
            } else {
786
                *dst = bgpixel;
787
            }
788
            dst++;
789
        }
790

791
#pragma pipeloop(0)
792
        for (; dst <= (dst_end - 2); dst += 2) {
793
            mlib_f32 *pp0 = (mlib_f32*)pixLut + src[0];
794
            mlib_f32 *pp1 = (mlib_f32*)pixLut + src[1];
795
            ARGB_to_GBGR_FL2(dd, *pp0, *pp1);
796
            mask = (((*(mlib_u8*)pp0) >> 6) & 2) | ((*(mlib_u8*)pp1) >> 7);
797
            *(mlib_d64*)dst = d_bgpixel;
798
            vis_pst_32(dd, dst, mask);
799
            src += 2;
800
        }
801

802
        while (dst < dst_end) {
803
            x = pixLut[*src++];
804
            if (x < 0) {
805
                *dst = ARGB_to_GBGR(x);
806
            } else {
807
                *dst = bgpixel;
808
            }
809
            dst++;
810
        }
811

812
        PTR_ADD(dstBase, dstScan);
813
        PTR_ADD(srcBase, srcScan);
814
    }
815
}
816

817
/***************************************************************/
818

819
void ADD_SUFF(IntBgrDrawGlyphListAA)(GLYPH_LIST_PARAMS)
820
{
821
    mlib_s32 glyphCounter;
822
    mlib_s32 scan = pRasInfo->scanStride;
823
    mlib_u8  *dstBase;
824
    mlib_s32 j;
825
    mlib_d64 dmix0, dmix1, dd, d0, d1, e0, e1, fgpixel_d;
826
    mlib_d64 done, done16, d_half, maskRGB, dzero;
827
    mlib_s32 pix, mask, mask_z;
828
    mlib_f32 srcG_f;
829

830
    done = vis_to_double_dup(0x7fff7fff);
831
    done16 = vis_to_double_dup(0x7fff);
832
    d_half = vis_to_double_dup((1 << (16 + 6)) | (1 << 6));
833

834
    fgpixel_d = vis_to_double_dup(fgpixel);
835
    srcG_f = vis_to_float(argbcolor);
836
    maskRGB = vis_to_double_dup(0xffffff);
837
    dzero = vis_fzero();
838

839
    ARGB2ABGR_FL(srcG_f)
840

841
    vis_write_gsr(0 << 3);
842

843
    for (glyphCounter = 0; glyphCounter < totalGlyphs; glyphCounter++) {
844
        const jubyte *pixels;
845
        unsigned int rowBytes;
846
        int left, top;
847
        int width, height;
848
        int right, bottom;
849

850
        pixels = (const jubyte *) glyphs[glyphCounter].pixels;
851

852
        if (!pixels) continue;
853

854
        left = glyphs[glyphCounter].x;
855
        top = glyphs[glyphCounter].y;
856
        width = glyphs[glyphCounter].width;
857
        height = glyphs[glyphCounter].height;
858
        rowBytes = width;
859
        right = left + width;
860
        bottom = top + height;
861
        if (left < clipLeft) {
862
            pixels += clipLeft - left;
863
            left = clipLeft;
864
        }
865
        if (top < clipTop) {
866
            pixels += (clipTop - top) * rowBytes;
867
            top = clipTop;
868
        }
869
        if (right > clipRight) {
870
            right = clipRight;
871
        }
872
        if (bottom > clipBottom) {
873
            bottom = clipBottom;
874
        }
875
        if (right <= left || bottom <= top) {
876
            continue;
877
        }
878
        width = right - left;
879
        height = bottom - top;
880

881
        dstBase = pRasInfo->rasBase;
882
        PTR_ADD(dstBase, top*scan + 4*left);
883

884
        for (j = 0; j < height; j++) {
885
            mlib_u8  *src = (void*)pixels;
886
            mlib_s32 *dst, *dst_end;
887

888
            dst = (void*)dstBase;
889
            dst_end = dst + width;
890

891
            if ((mlib_s32)dst & 7) {
892
                pix = *src++;
893
                if (pix) {
894
                    dd = vis_fpadd16(MUL8_VIS(srcG_f, pix), d_half);
895
                    dd = vis_fpadd16(MUL8_VIS(*(mlib_f32*)dst, 255 - pix), dd);
896
                    *(mlib_f32*)dst = vis_fands(vis_fpack16(dd),
897
                                                vis_read_hi(maskRGB));
898
                    if (pix == 255) *(mlib_f32*)dst = vis_read_hi(fgpixel_d);
899
                }
900
                dst++;
901
            }
902

903
#pragma pipeloop(0)
904
            for (; dst <= (dst_end - 2); dst += 2) {
905
                dmix0 = vis_freg_pair(((mlib_f32 *)vis_mul8s_tbl)[src[0]],
906
                                      ((mlib_f32 *)vis_mul8s_tbl)[src[1]]);
907
                mask = vis_fcmplt32(dmix0, done16);
908
                mask_z = vis_fcmpne32(dmix0, dzero);
909
                dmix1 = vis_fpsub16(done, dmix0);
910
                src += 2;
911

912
                dd = *(mlib_d64*)dst;
913
                d0 = vis_fmul8x16al(srcG_f, vis_read_hi(dmix0));
914
                d1 = vis_fmul8x16al(srcG_f, vis_read_lo(dmix0));
915
                e0 = vis_fmul8x16al(vis_read_hi(dd), vis_read_hi(dmix1));
916
                e1 = vis_fmul8x16al(vis_read_lo(dd), vis_read_lo(dmix1));
917
                d0 = vis_fpadd16(vis_fpadd16(d0, d_half), e0);
918
                d1 = vis_fpadd16(vis_fpadd16(d1, d_half), e1);
919
                dd = vis_fpack16_pair(d0, d1);
920
                dd = vis_fand(dd, maskRGB);
921

922
                vis_pst_32(fgpixel_d, dst, mask_z);
923
                vis_pst_32(dd, dst, mask & mask_z);
924
            }
925

926
            while (dst < dst_end) {
927
                pix = *src++;
928
                if (pix) {
929
                    dd = vis_fpadd16(MUL8_VIS(srcG_f, pix), d_half);
930
                    dd = vis_fpadd16(MUL8_VIS(*(mlib_f32*)dst, 255 - pix), dd);
931
                    *(mlib_f32*)dst = vis_fands(vis_fpack16(dd),
932
                                                vis_read_hi(maskRGB));
933
                    if (pix == 255) *(mlib_f32*)dst = vis_read_hi(fgpixel_d);
934
                }
935
                dst++;
936
            }
937

938
            PTR_ADD(dstBase, scan);
939
            pixels += rowBytes;
940
        }
941
    }
942
}
943

944
/***************************************************************/
945

946
#endif /* JAVA2D_NO_MLIB */
947

948
Product

Resources

Company
