CoCalc -- vis_FourByteAbgr.c

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

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

37
#if VIS >= 0x200
38

39
#define BMASK_FOR_ARGB         \
40
    vis_write_bmask(0x03214765, 0);
41

42
#else
43

44
#define BMASK_FOR_ARGB
45

46
#endif
47

48
/***************************************************************/
49

50
#define RGB2ABGR_DB(x)         \
51
    x = vis_for(x, amask);     \
52
    ARGB2ABGR_DB(x)
53

54
/***************************************************************/
55

56
#define INSERT_U8_34R                                          \
57
    sda = vis_fpmerge(vis_read_hi(sd0), vis_read_lo(sd1));     \
58
    sdb = vis_fpmerge(vis_read_lo(sd0), vis_read_hi(sd2));     \
59
    sdc = vis_fpmerge(vis_read_hi(sd1), vis_read_lo(sd2));     \
60
    sdd = vis_fpmerge(vis_read_hi(sda), vis_read_lo(sdb));     \
61
    sde = vis_fpmerge(vis_read_lo(sda), vis_read_hi(sdc));     \
62
    sdf = vis_fpmerge(vis_read_hi(sdb), vis_read_lo(sdc));     \
63
    sdg = vis_fpmerge(vis_read_hi(sdd), vis_read_lo(sde));     \
64
    sdh = vis_fpmerge(vis_read_lo(sdd), vis_read_hi(sdf));     \
65
    sdi = vis_fpmerge(vis_read_hi(sde), vis_read_lo(sdf));     \
66
    sdj = vis_fpmerge(vis_read_hi(sdg), vis_read_hi(sdi));     \
67
    sdk = vis_fpmerge(vis_read_lo(sdg), vis_read_lo(sdi));     \
68
    sdl = vis_fpmerge(vis_read_hi(sFF), vis_read_hi(sdh));     \
69
    sdm = vis_fpmerge(vis_read_lo(sFF), vis_read_lo(sdh));     \
70
    dd0 = vis_fpmerge(vis_read_hi(sdl), vis_read_hi(sdj));     \
71
    dd1 = vis_fpmerge(vis_read_lo(sdl), vis_read_lo(sdj));     \
72
    dd2 = vis_fpmerge(vis_read_hi(sdm), vis_read_hi(sdk));     \
73
    dd3 = vis_fpmerge(vis_read_lo(sdm), vis_read_lo(sdk))
74

75
/***************************************************************/
76

77
void IntArgbToIntAbgrConvert_line(mlib_s32 *srcBase,
78
                                  mlib_s32 *dstBase,
79
                                  mlib_s32 width)
80
{
81
    mlib_s32 *dst_end = dstBase + width;
82
    mlib_d64 dd;
83
    mlib_f32 ff;
84

85
    BMASK_FOR_ARGB
86

87
    if ((mlib_s32)srcBase & 7) {
88
        ff = *(mlib_f32*)srcBase;
89
        ARGB2ABGR_FL(ff)
90
        *(mlib_f32*)dstBase = ff;
91
        srcBase++;
92
        dstBase++;
93
    }
94

95
    if ((mlib_s32)dstBase & 7) {
96
#pragma pipeloop(0)
97
        for (; dstBase <= (dst_end - 2); dstBase += 2) {
98
            dd = *(mlib_d64*)srcBase;
99
            ARGB2ABGR_DB(dd)
100
            ((mlib_f32*)dstBase)[0] = vis_read_hi(dd);
101
            ((mlib_f32*)dstBase)[1] = vis_read_lo(dd);
102
            srcBase += 2;
103
        }
104
    } else {
105
#pragma pipeloop(0)
106
        for (; dstBase <= (dst_end - 2); dstBase += 2) {
107
            dd = *(mlib_d64*)srcBase;
108
            ARGB2ABGR_DB(dd)
109
            *(mlib_d64*)dstBase = dd;
110
            srcBase += 2;
111
        }
112
    }
113

114
    if (dstBase < dst_end) {
115
        ff = *(mlib_f32*)srcBase;
116
        ARGB2ABGR_FL(ff)
117
        *(mlib_f32*)dstBase = ff;
118
    }
119
}
120

121
/***************************************************************/
122

123
void ADD_SUFF(FourByteAbgrToIntArgbConvert)(BLIT_PARAMS)
124
{
125
    mlib_u32 *argb = (mlib_u32 *)dstBase;
126
    mlib_u8  *pabgr = (mlib_u8 *)srcBase;
127
    mlib_s32 dstScan = (pDstInfo)->scanStride;
128
    mlib_s32 srcScan = (pSrcInfo)->scanStride;
129
    mlib_s32 i, j, count, left;
130
    mlib_d64 w_abgr;
131

132
    if (width < 16) {
133
        for (j = 0; j < height; j++) {
134
            mlib_u8  *src = srcBase;
135
            mlib_s32 *dst = dstBase;
136

137
            for (i = 0; i < width; i++) {
138
                *dst++ = (src[0] << 24) | (src[3] << 16) |
139
                         (src[2] << 8) | (src[1]);
140
                src += 4;
141
            }
142

143
            PTR_ADD(dstBase, dstScan);
144
            PTR_ADD(srcBase, srcScan);
145
        }
146
        return;
147
    }
148

149
    if (dstScan == 4*width && srcScan == dstScan) {
150
        width *= height;
151
        height = 1;
152
    }
153
    count = width >> 1;
154
    left = width & 1;
155

156
    BMASK_FOR_ARGB
157

158
    if ((((mlib_addr)pabgr & 3) == 0) && ((srcScan & 3) == 0)) {
159
        mlib_u32 *abgr = (mlib_u32 *)pabgr;
160

161
        dstScan >>= 2;
162
        srcScan >>= 2;
163

164
        for (i = 0; i < height; i++, argb += dstScan, abgr += srcScan) {
165
            if ((((mlib_addr) argb | (mlib_addr) abgr) & 7) == 0) {
166
                mlib_d64 *d_abgr = (mlib_d64 *) abgr;
167
                mlib_d64 *d_argb = (mlib_d64 *) argb;
168

169
#pragma pipeloop(0)
170
                for (j = 0; j < count; j++) {
171
                    w_abgr = d_abgr[j];
172
                    ARGB2ABGR_DB(w_abgr)
173
                    d_argb[j] = w_abgr;
174
                }
175

176
                if (left) {
177
                    w_abgr = d_abgr[count];
178
                    ARGB2ABGR_DB(w_abgr)
179
                    ((mlib_f32 *) argb)[2 * count] = vis_read_hi(w_abgr);
180
                }
181
            } else {
182
                mlib_f32 v_abgr0, v_abgr1;
183

184
#pragma pipeloop(0)
185
                for (j = 0; j < count; j++) {
186
                    v_abgr0 = ((mlib_f32 *) abgr)[2 * j];
187
                    v_abgr1 = ((mlib_f32 *) abgr)[2 * j + 1];
188
                    w_abgr = vis_freg_pair(v_abgr0, v_abgr1);
189
                    ARGB2ABGR_DB(w_abgr)
190
                    ((mlib_f32 *) argb)[2 * j] = vis_read_hi(w_abgr);
191
                    ((mlib_f32 *) argb)[2 * j + 1] = vis_read_lo(w_abgr);
192
                }
193

194
                if (left) {
195
                    v_abgr0 = ((mlib_f32 *) abgr)[2 * count];
196
                    w_abgr = vis_freg_pair(v_abgr0, 0);
197
                    ARGB2ABGR_DB(w_abgr)
198
                    ((mlib_f32 *) argb)[2 * count] = vis_read_hi(w_abgr);
199
                }
200
            }
201
        }
202
    } else {      /* abgr is not aligned */
203
        mlib_u8 *abgr = pabgr;
204
        mlib_d64 *d_abgr, db0, db1;
205

206
        dstScan >>= 2;
207

208
        for (i = 0; i < height; i++, argb += dstScan, abgr += srcScan) {
209
            d_abgr = vis_alignaddr(abgr, 0);
210
            db0 = *d_abgr++;
211

212
            if (((mlib_addr) argb & 7) == 0) {
213
                mlib_d64 *d_argb = (mlib_d64 *) argb;
214

215
#pragma pipeloop(0)
216
                for (j = 0; j < count; j++) {
217
                    db1 = d_abgr[j];
218
                    w_abgr = vis_faligndata(db0, db1);
219
                    db0 = db1;
220
                    ARGB2ABGR_DB(w_abgr)
221
                    d_argb[j] = w_abgr;
222
                }
223

224
                if (left) {
225
                    db1 = d_abgr[j];
226
                    w_abgr = vis_faligndata(db0, db1);
227
                    ARGB2ABGR_DB(w_abgr)
228
                    ((mlib_f32 *) argb)[2 * count] = vis_read_hi(w_abgr);
229
                }
230
            } else {
231
                mlib_d64 w_abgr;
232

233
                db1 = *d_abgr++;
234
                w_abgr = vis_faligndata(db0, db1);
235
                db0 = db1;
236
#pragma pipeloop(0)
237
                for (j = 0; j < count; j++) {
238
                    ARGB2ABGR_DB(w_abgr)
239
                    ((mlib_f32 *) argb)[2 * j] = vis_read_hi(w_abgr);
240
                    ((mlib_f32 *) argb)[2 * j + 1] = vis_read_lo(w_abgr);
241
                    db1 = d_abgr[j];
242
                    w_abgr = vis_faligndata(db0, db1);
243
                    db0 = db1;
244
                }
245

246
                if (left) {
247
                    ARGB2ABGR_DB(w_abgr)
248
                    ((mlib_f32 *) argb)[2 * count] = vis_read_hi(w_abgr);
249
                }
250
            }
251
        }
252
    }
253
}
254

255
/***************************************************************/
256

257
void ADD_SUFF(IntArgbToFourByteAbgrConvert)(BLIT_PARAMS)
258
{
259
    mlib_u32 *argb = (mlib_u32 *)srcBase;
260
    mlib_u8 *abgr = (mlib_u8 *)dstBase;
261
    mlib_s32 dstScan = (pDstInfo)->scanStride;
262
    mlib_s32 srcScan = (pSrcInfo)->scanStride;
263
    mlib_s32 i, j, count, left;
264
    mlib_d64 w_abgr;
265

266
    if (width < 16) {
267
        for (j = 0; j < height; j++) {
268
            mlib_s32 *src = srcBase;
269
            mlib_u8  *dst = dstBase;
270

271
            for (i = 0; i < width; i++) {
272
                mlib_u32 x = *src++;
273
                dst[0] = x >> 24;
274
                dst[1] = x;
275
                dst[2] = x >> 8;
276
                dst[3] = x >> 16;
277
                dst += 4;
278
            }
279

280
            PTR_ADD(dstBase, dstScan);
281
            PTR_ADD(srcBase, srcScan);
282
        }
283
        return;
284
    }
285

286
    if (dstScan == 4*width && srcScan == dstScan) {
287
        width *= height;
288
        height = 1;
289
    }
290
    count = width >> 1;
291
    left = width & 1;
292

293
    BMASK_FOR_ARGB
294

295
    srcScan >>= 2;
296

297
    for (i = 0; i < height; i++, argb += srcScan, abgr += dstScan) {
298

299
        if ((((mlib_addr) abgr | (mlib_addr) argb) & 7) == 0) {
300
            mlib_d64 *d_argb = (mlib_d64 *) argb;
301
            mlib_d64 *d_abgr = (mlib_d64 *) abgr;
302

303
#pragma pipeloop(0)
304
            for (j = 0; j < count; j++) {
305
                w_abgr = d_argb[j];
306
                ARGB2ABGR_DB(w_abgr)
307
                d_abgr[j] = w_abgr;
308
            }
309

310
            if (left) {
311
                w_abgr = d_argb[count];
312
                ARGB2ABGR_DB(w_abgr)
313
                ((mlib_f32 *) abgr)[2 * count] = vis_read_hi(w_abgr);
314
            }
315

316
        } else if (((mlib_addr) abgr & 3) == 0) {
317
            mlib_f32 v_argb0, v_argb1;
318

319
#pragma pipeloop(0)
320
            for (j = 0; j < count; j++) {
321
                v_argb0 = ((mlib_f32 *) argb)[2 * j];
322
                v_argb1 = ((mlib_f32 *) argb)[2 * j + 1];
323
                w_abgr = vis_freg_pair(v_argb0, v_argb1);
324

325
                ARGB2ABGR_DB(w_abgr)
326
                ((mlib_f32 *) abgr)[2 * j] = vis_read_hi(w_abgr);
327
                ((mlib_f32 *) abgr)[2 * j + 1] = vis_read_lo(w_abgr);
328
            }
329

330
            if (left) {
331
                v_argb0 = ((mlib_f32 *) argb)[2 * count];
332
                w_abgr = vis_freg_pair(v_argb0, vis_fzeros());
333

334
                ARGB2ABGR_DB(w_abgr)
335
                ((mlib_f32 *) abgr)[2 * count] = vis_read_hi(w_abgr);
336
            }
337

338
        } else {      /* abgr is not aligned */
339

340
            mlib_u8 *pend = abgr + (width << 2) - 1;
341
            mlib_d64 *d_abgr, db0, db1;
342
            mlib_s32 emask, off;
343
            mlib_f32 *f_argb = (mlib_f32 *) argb;
344

345
            off = (mlib_addr)abgr & 7;
346
            vis_alignaddr((void *)(8 - off), 0);
347
            d_abgr = (mlib_d64 *) (abgr - off);
348

349
            db1 = vis_freg_pair(*f_argb++, *f_argb++);
350
            ARGB2ABGR_DB(db1)
351
            w_abgr = vis_faligndata(db1, db1);
352
            emask = vis_edge8(abgr, pend);
353
            vis_pst_8(w_abgr, d_abgr++, emask);
354
            db0 = db1;
355

356
            db1 = vis_freg_pair(f_argb[0], f_argb[1]);
357
#pragma pipeloop(0)
358
            for (; (mlib_addr)d_abgr < (mlib_addr)(pend - 6); ) {
359
                ARGB2ABGR_DB(db1)
360
                w_abgr = vis_faligndata(db0, db1);
361
                *d_abgr++ = w_abgr;
362
                db0 = db1;
363
                f_argb += 2;
364
                db1 = vis_freg_pair(f_argb[0], f_argb[1]);
365
            }
366

367
            if ((mlib_addr)d_abgr <= (mlib_addr)pend) {
368
                ARGB2ABGR_DB(db1)
369
                w_abgr = vis_faligndata(db0, db1);
370
                emask = vis_edge8(d_abgr, pend);
371
                vis_pst_8(w_abgr, d_abgr, emask);
372
            }
373
        }
374
    }
375
}
376

377
/***************************************************************/
378

379
void ADD_SUFF(IntRgbToFourByteAbgrConvert)(BLIT_PARAMS)
380
{
381
    mlib_u32 *argb = (mlib_u32 *)srcBase;
382
    mlib_u8  *abgr = (mlib_u8 *)dstBase;
383
    mlib_s32 dstScan = (pDstInfo)->scanStride;
384
    mlib_s32 srcScan = (pSrcInfo)->scanStride;
385
    mlib_s32 i, j, count, left;
386
    mlib_d64 w_abgr;
387
    mlib_d64 amask = vis_to_double_dup(0xFF000000);
388

389
    if (width < 16) {
390
        for (j = 0; j < height; j++) {
391
            mlib_s32 *src = srcBase;
392
            mlib_u8  *dst = dstBase;
393

394
            for (i = 0; i < width; i++) {
395
                mlib_u32 x = *src++;
396
                dst[0] = 0xFF;
397
                dst[1] = x;
398
                dst[2] = x >> 8;
399
                dst[3] = x >> 16;
400
                dst += 4;
401
            }
402

403
            PTR_ADD(dstBase, dstScan);
404
            PTR_ADD(srcBase, srcScan);
405
        }
406
        return;
407
    }
408

409
    if (dstScan == 4*width && srcScan == dstScan) {
410
        width *= height;
411
        height = 1;
412
    }
413
    count = width >> 1;
414
    left = width & 1;
415

416
    BMASK_FOR_ARGB
417

418
    srcScan >>= 2;
419

420
    for (i = 0; i < height; i++, argb += srcScan, abgr += dstScan) {
421

422
        if ((((mlib_addr) abgr | (mlib_addr) argb) & 7) == 0) {
423
            mlib_d64 *d_argb = (mlib_d64 *) argb;
424
            mlib_d64 *d_abgr = (mlib_d64 *) abgr;
425

426
#pragma pipeloop(0)
427
            for (j = 0; j < count; j++) {
428
                w_abgr = d_argb[j];
429
                RGB2ABGR_DB(w_abgr)
430
                d_abgr[j] = w_abgr;
431
            }
432

433
            if (left) {
434
                w_abgr = d_argb[count];
435
                RGB2ABGR_DB(w_abgr)
436
                ((mlib_f32 *) abgr)[2 * count] = vis_read_hi(w_abgr);
437
            }
438

439
        } else if (((mlib_addr) abgr & 3) == 0) {
440
            mlib_f32 v_argb0, v_argb1;
441

442
#pragma pipeloop(0)
443
            for (j = 0; j < count; j++) {
444
                v_argb0 = ((mlib_f32 *) argb)[2 * j];
445
                v_argb1 = ((mlib_f32 *) argb)[2 * j + 1];
446
                w_abgr = vis_freg_pair(v_argb0, v_argb1);
447

448
                RGB2ABGR_DB(w_abgr)
449
                ((mlib_f32 *) abgr)[2 * j] = vis_read_hi(w_abgr);
450
                ((mlib_f32 *) abgr)[2 * j + 1] = vis_read_lo(w_abgr);
451
            }
452

453
            if (left) {
454
                v_argb0 = ((mlib_f32 *) argb)[2 * count];
455
                w_abgr = vis_freg_pair(v_argb0, vis_fzeros());
456

457
                RGB2ABGR_DB(w_abgr)
458
                ((mlib_f32 *) abgr)[2 * count] = vis_read_hi(w_abgr);
459
            }
460

461
        } else {      /* abgr is not aligned */
462

463
            mlib_u8 *pend = abgr + (width << 2) - 1;
464
            mlib_d64 *d_abgr, db0, db1;
465
            mlib_s32 emask, off;
466
            mlib_f32 *f_argb = (mlib_f32 *) argb;
467

468
            off = (mlib_addr)abgr & 7;
469
            vis_alignaddr((void *)(8 - off), 0);
470
            d_abgr = (mlib_d64 *) (abgr - off);
471

472
            db1 = vis_freg_pair(*f_argb++, *f_argb++);
473
            RGB2ABGR_DB(db1)
474
            w_abgr = vis_faligndata(db1, db1);
475
            emask = vis_edge8(abgr, pend);
476
            vis_pst_8(w_abgr, d_abgr++, emask);
477
            db0 = db1;
478

479
            db1 = vis_freg_pair(f_argb[0], f_argb[1]);
480
#pragma pipeloop(0)
481
            for (; (mlib_addr)d_abgr < (mlib_addr)(pend - 6); ) {
482
                RGB2ABGR_DB(db1)
483
                w_abgr = vis_faligndata(db0, db1);
484
                *d_abgr++ = w_abgr;
485
                db0 = db1;
486
                f_argb += 2;
487
                db1 = vis_freg_pair(f_argb[0], f_argb[1]);
488
            }
489

490
            if ((mlib_addr)d_abgr <= (mlib_addr)pend) {
491
                RGB2ABGR_DB(db1)
492
                w_abgr = vis_faligndata(db0, db1);
493
                emask = vis_edge8(d_abgr, pend);
494
                vis_pst_8(w_abgr, d_abgr, emask);
495
            }
496
        }
497
    }
498
}
499

500
/***************************************************************/
501

502
void ADD_SUFF(ThreeByteBgrToFourByteAbgrConvert)(BLIT_PARAMS)
503
{
504
    mlib_s32 dstScan = pDstInfo->scanStride;
505
    mlib_s32 srcScan = pSrcInfo->scanStride;
506
    mlib_d64 sd0, sd1, sd2;
507
    mlib_d64 dd0, dd1, dd2, dd3;
508
    mlib_d64 sda, sdb, sdc, sdd;
509
    mlib_d64 sde, sdf, sdg, sdh;
510
    mlib_d64 sdi, sdj, sdk, sdl;
511
    mlib_d64 sdm;
512
    mlib_d64 sFF;
513
    mlib_s32 r, g, b;
514
    mlib_s32 i, j;
515

516
    if (width < 16) {
517
        for (j = 0; j < height; j++) {
518
            mlib_u8 *src = srcBase;
519
            mlib_u8 *dst = dstBase;
520

521
#pragma pipeloop(0)
522
            for (i = 0; i < width; i++) {
523
                dst[0] = 0xFF;
524
                dst[1] = src[0];
525
                dst[2] = src[1];
526
                dst[3] = src[2];
527
                src += 3;
528
                dst += 4;
529
            }
530

531
            PTR_ADD(dstBase, dstScan);
532
            PTR_ADD(srcBase, srcScan);
533
        }
534
        return;
535
    }
536

537
    if (dstScan == 4*width && srcScan == 3*width) {
538
        width *= height;
539
        height = 1;
540
    }
541

542
    sFF = vis_fone();
543

544
    for (j = 0; j < height; j++) {
545
        mlib_u8 *pSrc = srcBase;
546
        mlib_u8 *pDst = dstBase;
547

548
        if (!(((mlib_s32)pSrc | (mlib_s32)pDst) & 7)) {
549
#pragma pipeloop(0)
550
            for (i = 0; i <= ((mlib_s32)width - 8); i += 8) {
551
                sd0 = ((mlib_d64*)pSrc)[0];
552
                sd1 = ((mlib_d64*)pSrc)[1];
553
                sd2 = ((mlib_d64*)pSrc)[2];
554
                pSrc += 3*8;
555
                INSERT_U8_34R;
556
                ((mlib_d64*)pDst)[0] = dd0;
557
                ((mlib_d64*)pDst)[1] = dd1;
558
                ((mlib_d64*)pDst)[2] = dd2;
559
                ((mlib_d64*)pDst)[3] = dd3;
560
                pDst += 4*8;
561
            }
562

563
            for (; i < width; i++) {
564
                b = pSrc[0];
565
                g = pSrc[1];
566
                r = pSrc[2];
567
                ((mlib_u16*)pDst)[0] = 0xff00 | b;
568
                ((mlib_u16*)pDst)[1] = (g << 8) | r;
569
                pSrc += 3;
570
                pDst += 4;
571
            }
572
        } else if (!((mlib_s32)pDst & 1)) {
573
#pragma pipeloop(0)
574
            for (i = 0; i < width; i++) {
575
                b = pSrc[0];
576
                g = pSrc[1];
577
                r = pSrc[2];
578
                ((mlib_u16*)pDst)[0] = 0xff00 | b;
579
                ((mlib_u16*)pDst)[1] = (g << 8) | r;
580
                pSrc += 3;
581
                pDst += 4;
582
            }
583
        } else {
584
            *pDst++ = 0xff;
585
#pragma pipeloop(0)
586
            for (i = 0; i < (mlib_s32)width - 1; i++) {
587
                b = pSrc[0];
588
                g = pSrc[1];
589
                r = pSrc[2];
590
                ((mlib_u16*)pDst)[0] = (b << 8) | g;
591
                ((mlib_u16*)pDst)[1] = (r << 8) | 0xff;
592
                pSrc += 3;
593
                pDst += 4;
594
            }
595
            if (width) {
596
                pDst[0] = pSrc[0];
597
                pDst[1] = pSrc[1];
598
                pDst[2] = pSrc[2];
599
            }
600
        }
601

602
        PTR_ADD(dstBase, dstScan);
603
        PTR_ADD(srcBase, srcScan);
604
    }
605
}
606

607
/***************************************************************/
608

609
#if 1
610

611
#define LOAD_BGR(dd) {                                 \
612
    mlib_u8  *sp = pSrc - 1 + 3*(tmpsxloc >> shift);   \
613
    mlib_d64 *ap = (void*)((mlib_addr)sp &~ 7);        \
614
    vis_alignaddr(sp, 0);                              \
615
    dd = vis_faligndata(ap[0], ap[1]);                 \
616
    tmpsxloc += sxinc;                                 \
617
}
618

619
#else
620

621
#define LOAD_BGR(dd) {                                 \
622
    mlib_u8 *sp = pSrc + 3*(tmpsxloc >> shift);        \
623
    dd = vis_faligndata(vis_ld_u8(sp + 2), dd);        \
624
    dd = vis_faligndata(vis_ld_u8(sp + 1), dd);        \
625
    dd = vis_faligndata(vis_ld_u8(sp    ), dd);        \
626
    dd = vis_faligndata(amask, dd);                    \
627
    tmpsxloc += sxinc;                                 \
628
}
629

630
#endif
631

632
/***************************************************************/
633

634
void ADD_SUFF(ThreeByteBgrToFourByteAbgrScaleConvert)(SCALE_PARAMS)
635
{
636
    mlib_s32 dstScan = pDstInfo->scanStride;
637
    mlib_s32 srcScan = pSrcInfo->scanStride;
638
    mlib_d64 d0;
639
    mlib_d64 amask;
640
    mlib_s32 r, g, b;
641
    mlib_s32 i, j;
642

643
    if (width < 16 /*|| (((mlib_s32)dstBase | dstScan) & 3)*/) {
644
        for (j = 0; j < height; j++) {
645
            mlib_u8  *pSrc = srcBase;
646
            mlib_u8  *pDst = dstBase;
647
            mlib_s32 tmpsxloc = sxloc;
648

649
            PTR_ADD(pSrc, (syloc >> shift) * srcScan);
650

651
#pragma pipeloop(0)
652
            for (i = 0; i < width; i++) {
653
                mlib_u8 *pp = pSrc + 3*(tmpsxloc >> shift);
654
                pDst[0] = 0xff;
655
                pDst[1] = pp[0];
656
                pDst[2] = pp[1];
657
                pDst[3] = pp[2];
658
                tmpsxloc += sxinc;
659
                pDst += 4;
660
            }
661

662
            PTR_ADD(dstBase, dstScan);
663
            syloc += syinc;
664
        }
665
        return;
666
    }
667

668
    vis_alignaddr(NULL, 7);
669
    amask = vis_to_double_dup(0xFF000000);
670

671
    for (j = 0; j < height; j++) {
672
        mlib_u8 *pSrc = srcBase;
673
        mlib_u8 *pDst = dstBase;
674
        mlib_s32 tmpsxloc = sxloc;
675

676
        PTR_ADD(pSrc, (syloc >> shift) * srcScan);
677

678
        if (!((mlib_s32)pDst & 3)) {
679
#pragma pipeloop(0)
680
            for (i = 0; i < width; i++) {
681
                LOAD_BGR(d0);
682
                ((mlib_f32*)pDst)[0] = vis_fors(vis_read_hi(d0),
683
                                                vis_read_hi(amask));
684
                pDst += 4;
685
            }
686
        } else if (!((mlib_s32)pDst & 1)) {
687
#pragma pipeloop(0)
688
            for (i = 0; i < width; i++) {
689
                mlib_u8 *pp = pSrc + 3*(tmpsxloc >> shift);
690
                tmpsxloc += sxinc;
691
                b = pp[0];
692
                g = pp[1];
693
                r = pp[2];
694
                ((mlib_u16*)pDst)[2*i    ] = 0xff00 | b;
695
                ((mlib_u16*)pDst)[2*i + 1] = (g << 8) | r;
696
            }
697
        } else {
698
            *pDst++ = 0xff;
699
#pragma pipeloop(0)
700
            for (i = 0; i < (mlib_s32)width - 1; i++) {
701
                mlib_u8 *pp = pSrc + 3*(tmpsxloc >> shift);
702
                tmpsxloc += sxinc;
703
                b = pp[0];
704
                g = pp[1];
705
                r = pp[2];
706
                ((mlib_u16*)pDst)[2*i    ] = (b << 8) | g;
707
                ((mlib_u16*)pDst)[2*i + 1] = (r << 8) | 0xff;
708
            }
709
            if (width) {
710
                mlib_u8 *pp = pSrc + 3*(tmpsxloc >> shift);
711
                tmpsxloc += sxinc;
712
                pDst[4*i  ] = pp[0];
713
                pDst[4*i+1] = pp[1];
714
                pDst[4*i+2] = pp[2];
715
            }
716
        }
717

718
        PTR_ADD(dstBase, dstScan);
719
        syloc += syinc;
720
    }
721
}
722

723
/***************************************************************/
724

725
void ADD_SUFF(ByteGrayToFourByteAbgrConvert)(BLIT_PARAMS)
726
{
727
    mlib_s32 dstScan = pDstInfo->scanStride;
728
    mlib_s32 srcScan = pSrcInfo->scanStride;
729
    mlib_d64 d0, d1, d2, d3;
730
    mlib_f32 ff, aa = vis_fones();
731
    mlib_s32 i, j, x;
732

733
    if (!(((mlib_s32)dstBase | dstScan) & 3)) {
734
        ADD_SUFF(ByteGrayToIntArgbConvert)(BLIT_CALL_PARAMS);
735
        return;
736
    }
737

738
    if (width < 16) {
739
        for (j = 0; j < height; j++) {
740
            mlib_u8 *src = srcBase;
741
            mlib_u8 *dst = dstBase;
742

743
            for (i = 0; i < width; i++) {
744
                x = *src++;
745
                dst[0] = 0xff;
746
                dst[1] = x;
747
                dst[2] = x;
748
                dst[3] = x;
749
                dst += 4;
750
            }
751

752
            PTR_ADD(dstBase, dstScan);
753
            PTR_ADD(srcBase, srcScan);
754
        }
755
        return;
756
    }
757

758
    if (srcScan == width && dstScan == 4*width) {
759
        width *= height;
760
        height = 1;
761
    }
762

763
    for (j = 0; j < height; j++) {
764
        mlib_u8 *src = srcBase;
765
        mlib_u8 *dst = dstBase;
766
        mlib_u8 *dst_end;
767

768
        dst_end = dst + 4*width;
769

770
        while (((mlib_s32)src & 3) && dst < dst_end) {
771
            x = *src++;
772
            dst[0] = 0xff;
773
            dst[1] = x;
774
            dst[2] = x;
775
            dst[3] = x;
776
            dst += 4;
777
        }
778

779
        if (!((mlib_s32)dst & 3)) {
780
#pragma pipeloop(0)
781
            for (; dst <= (dst_end - 4*4); dst += 4*4) {
782
                ff = *(mlib_f32*)src;
783
                d0 = vis_fpmerge(aa, ff);
784
                d1 = vis_fpmerge(ff, ff);
785
                d2 = vis_fpmerge(vis_read_hi(d0), vis_read_hi(d1));
786
                d3 = vis_fpmerge(vis_read_lo(d0), vis_read_lo(d1));
787
                ((mlib_f32*)dst)[0] = vis_read_hi(d2);
788
                ((mlib_f32*)dst)[1] = vis_read_lo(d2);
789
                ((mlib_f32*)dst)[2] = vis_read_hi(d3);
790
                ((mlib_f32*)dst)[3] = vis_read_lo(d3);
791
                src += 4;
792
            }
793
        } else {
794
            mlib_d64 *dp;
795

796
            dp = vis_alignaddr(dst, 0);
797
            d3 = vis_faligndata(dp[0], dp[0]);
798
            vis_alignaddrl(dst, 0);
799

800
#pragma pipeloop(0)
801
            for (; dst <= (dst_end - 4*4); dst += 4*4) {
802
                ff = *(mlib_f32*)src;
803
                d0 = vis_fpmerge(aa, ff);
804
                d1 = vis_fpmerge(ff, ff);
805
                d2 = vis_fpmerge(vis_read_hi(d0), vis_read_hi(d1));
806
                *dp++ = vis_faligndata(d3, d2);
807
                d3 = vis_fpmerge(vis_read_lo(d0), vis_read_lo(d1));
808
                *dp++ = vis_faligndata(d2, d3);
809
                src += 4;
810
            }
811

812
            vis_pst_8(vis_faligndata(d3, d3), dp, vis_edge8(dp, dst - 1));
813
        }
814

815
        while (dst < dst_end) {
816
            x = *src++;
817
            dst[0] = 0xff;
818
            dst[1] = x;
819
            dst[2] = x;
820
            dst[3] = x;
821
            dst += 4;
822
        }
823

824
        PTR_ADD(dstBase, dstScan);
825
        PTR_ADD(srcBase, srcScan);
826
    }
827
}
828

829
/***************************************************************/
830

831
void ADD_SUFF(IntArgbToFourByteAbgrXorBlit)(BLIT_PARAMS)
832
{
833
    mlib_s32 dstScan = pDstInfo->scanStride;
834
    mlib_s32 srcScan = pSrcInfo->scanStride;
835
    mlib_u32 xorpixel = pCompInfo->details.xorPixel;
836
    mlib_u32 alphamask = pCompInfo->alphaMask;
837
    mlib_d64 dd, d_xorpixel, d_alphamask, d_zero;
838
    mlib_s32 i, j, x, neg_mask;
839

840
    if (width < 16) {
841
        xorpixel = (xorpixel << 24) | (xorpixel >> 8);
842
        alphamask = (alphamask << 24) | (alphamask >> 8);
843

844
        for (j = 0; j < height; j++) {
845
            mlib_s32 *src = srcBase;
846
            mlib_u8  *dst = dstBase;
847

848
            for (i = 0; i < width; i++) {
849
                x = src[i];
850
                neg_mask = x >> 31;
851
                x = (x ^ xorpixel) & (neg_mask &~ alphamask);
852
                dst[0] ^= x >> 24;
853
                dst[1] ^= x;
854
                dst[2] ^= x >> 8;
855
                dst[3] ^= x >> 16;
856
                dst += 4;
857
            }
858

859
            PTR_ADD(dstBase, dstScan);
860
            PTR_ADD(srcBase, srcScan);
861
        }
862
        return;
863
    }
864

865
    if (srcScan == 4*width && dstScan == 4*width) {
866
        width *= height;
867
        height = 1;
868
    }
869

870
    d_zero = vis_fzero();
871
    d_xorpixel = vis_freg_pair(vis_ldfa_ASI_PL(&xorpixel),
872
                               vis_ldfa_ASI_PL(&xorpixel));
873
    d_alphamask = vis_freg_pair(vis_ldfa_ASI_PL(&alphamask),
874
                                vis_ldfa_ASI_PL(&alphamask));
875

876
    dd = vis_freg_pair(vis_read_hi(d_xorpixel), vis_read_hi(d_alphamask));
877
    ARGB2ABGR_DB(dd)
878
    xorpixel = ((mlib_s32*)&dd)[0];
879
    alphamask = ((mlib_s32*)&dd)[1];
880

881
    for (j = 0; j < height; j++) {
882
        mlib_s32 *src = srcBase;
883
        mlib_u8  *dst = dstBase;
884
        mlib_u8  *dst_end;
885

886
        dst_end = dst + 4*width;
887

888
        if (!((mlib_s32)dst & 7)) {
889
#pragma pipeloop(0)
890
            for (; dst <= (dst_end - 8); dst += 8) {
891
                dd = vis_freg_pair(((mlib_f32*)src)[0], ((mlib_f32*)src)[1]);
892
                src += 2;
893
                neg_mask = vis_fcmplt32(dd, d_zero);
894
                ARGB2ABGR_DB(dd)
895
                dd = vis_fxor(dd, d_xorpixel);
896
                dd = vis_fandnot(d_alphamask, dd);
897
                dd = vis_fxor(dd, *(mlib_d64*)dst);
898
                vis_pst_32(dd, dst, neg_mask);
899
            }
900
        }
901

902
        while (dst < dst_end) {
903
            x = *src++;
904
            neg_mask = x >> 31;
905
            x = (x ^ xorpixel) & (neg_mask &~ alphamask);
906
            dst[0] ^= x >> 24;
907
            dst[1] ^= x;
908
            dst[2] ^= x >> 8;
909
            dst[3] ^= x >> 16;
910
            dst += 4;
911
        }
912

913
        PTR_ADD(dstBase, dstScan);
914
        PTR_ADD(srcBase, srcScan);
915
    }
916
}
917

918
/***************************************************************/
919

920
void ADD_SUFF(ByteGrayToFourByteAbgrScaleConvert)(SCALE_PARAMS)
921
{
922
    mlib_s32 dstScan = pDstInfo->scanStride;
923
    mlib_s32 srcScan = pSrcInfo->scanStride;
924
    mlib_d64 d0, d1, d2, d3, dd;
925
    mlib_f32 ff, aa;
926
    mlib_s32 i, j, x;
927

928
/*  if (!(((mlib_s32)dstBase | dstScan) & 3)) {
929
    ADD_SUFF(ByteGrayToIntArgbScaleConvert)(SCALE_CALL_PARAMS);
930
    return;
931
    }*/
932

933
    if (width < 16) {
934
        for (j = 0; j < height; j++) {
935
            mlib_u8 *src = srcBase;
936
            mlib_u8 *dst = dstBase;
937
            mlib_s32 tmpsxloc = sxloc;
938

939
            PTR_ADD(src, (syloc >> shift) * srcScan);
940

941
            for (i = 0; i < width; i++) {
942
                x = src[tmpsxloc >> shift];
943
                tmpsxloc += sxinc;
944
                dst[4*i    ] = 0xff;
945
                dst[4*i + 1] = x;
946
                dst[4*i + 2] = x;
947
                dst[4*i + 3] = x;
948
            }
949

950
            PTR_ADD(dstBase, dstScan);
951
            syloc += syinc;
952
        }
953
        return;
954
    }
955

956
    aa = vis_fones();
957

958
    for (j = 0; j < height; j++) {
959
        mlib_u8 *src = srcBase;
960
        mlib_u8 *dst = dstBase;
961
        mlib_u8 *dst_end;
962
        mlib_s32 tmpsxloc = sxloc;
963

964
        PTR_ADD(src, (syloc >> shift) * srcScan);
965

966
        dst_end = dst + 4*width;
967

968
        if (!((mlib_s32)dst & 3)) {
969
            vis_alignaddr(NULL, 7);
970
#pragma pipeloop(0)
971
            for (; dst <= (dst_end - 4*4); dst += 4*4) {
972
                LOAD_NEXT_U8(dd, src + ((tmpsxloc + 3*sxinc) >> shift));
973
                LOAD_NEXT_U8(dd, src + ((tmpsxloc + 2*sxinc) >> shift));
974
                LOAD_NEXT_U8(dd, src + ((tmpsxloc +   sxinc) >> shift));
975
                LOAD_NEXT_U8(dd, src + ((tmpsxloc          ) >> shift));
976
                tmpsxloc += 4*sxinc;
977
                ff = vis_read_hi(dd);
978
                d0 = vis_fpmerge(aa, ff);
979
                d1 = vis_fpmerge(ff, ff);
980
                d2 = vis_fpmerge(vis_read_hi(d0), vis_read_hi(d1));
981
                d3 = vis_fpmerge(vis_read_lo(d0), vis_read_lo(d1));
982
                ((mlib_f32*)dst)[0] = vis_read_hi(d2);
983
                ((mlib_f32*)dst)[1] = vis_read_lo(d2);
984
                ((mlib_f32*)dst)[2] = vis_read_hi(d3);
985
                ((mlib_f32*)dst)[3] = vis_read_lo(d3);
986
            }
987
        } else {
988
            mlib_d64 *dp;
989

990
            dp = vis_alignaddr(dst, 0);
991
            d3 = vis_faligndata(dp[0], dp[0]);
992
            vis_alignaddrl(dst, 0);
993

994
#pragma pipeloop(0)
995
            for (; dst <= (dst_end - 4*4); dst += 4*4) {
996
                mlib_d64 s0, s1, s2, s3;
997
                s0 = vis_ld_u8(src + ((tmpsxloc          ) >> shift));
998
                s1 = vis_ld_u8(src + ((tmpsxloc +   sxinc) >> shift));
999
                s2 = vis_ld_u8(src + ((tmpsxloc + 2*sxinc) >> shift));
1000
                s3 = vis_ld_u8(src + ((tmpsxloc + 3*sxinc) >> shift));
1001
                tmpsxloc += 4*sxinc;
1002
                s0 = vis_fpmerge(vis_read_lo(s0), vis_read_lo(s2));
1003
                s1 = vis_fpmerge(vis_read_lo(s1), vis_read_lo(s3));
1004
                dd = vis_fpmerge(vis_read_lo(s0), vis_read_lo(s1));
1005
                ff = vis_read_lo(dd);
1006
                d0 = vis_fpmerge(aa, ff);
1007
                d1 = vis_fpmerge(ff, ff);
1008
                d2 = vis_fpmerge(vis_read_hi(d0), vis_read_hi(d1));
1009
                *dp++ = vis_faligndata(d3, d2);
1010
                d3 = vis_fpmerge(vis_read_lo(d0), vis_read_lo(d1));
1011
                *dp++ = vis_faligndata(d2, d3);
1012
            }
1013

1014
            vis_pst_8(vis_faligndata(d3, d3), dp, vis_edge8(dp, dst - 1));
1015
        }
1016

1017
        while (dst < dst_end) {
1018
            x = src[tmpsxloc >> shift];
1019
            tmpsxloc += sxinc;
1020
            dst[0] = 0xff;
1021
            dst[1] = x;
1022
            dst[2] = x;
1023
            dst[3] = x;
1024
            dst += 4;
1025
        }
1026

1027
        PTR_ADD(dstBase, dstScan);
1028
        syloc += syinc;
1029
    }
1030
}
1031

1032
/***************************************************************/
1033

1034
void ADD_SUFF(ByteIndexedToFourByteAbgrConvert)(BLIT_PARAMS)
1035
{
1036
    jint *pixLut = pSrcInfo->lutBase;
1037
    mlib_s32 dstScan = pDstInfo->scanStride;
1038
    mlib_s32 srcScan = pSrcInfo->scanStride;
1039
    mlib_d64 dd, d_old;
1040
    mlib_s32 i, j, x;
1041

1042
/*  if (!(((mlib_s32)dstBase | dstScan) & 3)) {
1043
    ADD_SUFF(ByteIndexedToIntAbgrConvert)(BLIT_CALL_PARAMS);
1044
    return;
1045
    }*/
1046

1047
    if (width < 8) {
1048
        for (j = 0; j < height; j++) {
1049
            mlib_u8 *src = srcBase;
1050
            mlib_u8 *dst = dstBase;
1051

1052
            for (i = 0; i < width; i++) {
1053
                x = pixLut[src[i]];
1054
                dst[4*i    ] = x >> 24;
1055
                dst[4*i + 1] = x;
1056
                dst[4*i + 2] = x >> 8;
1057
                dst[4*i + 3] = x >> 16;
1058
            }
1059

1060
            PTR_ADD(dstBase, dstScan);
1061
            PTR_ADD(srcBase, srcScan);
1062
        }
1063
        return;
1064
    }
1065

1066
    if (srcScan == width && dstScan == 4*width) {
1067
        width *= height;
1068
        height = 1;
1069
    }
1070

1071
    BMASK_FOR_ARGB
1072

1073
    for (j = 0; j < height; j++) {
1074
        mlib_u8 *src = srcBase;
1075
        mlib_u8 *dst = dstBase;
1076
        mlib_u8 *dst_end;
1077

1078
        dst_end = dst + 4*width;
1079

1080
        if (!((mlib_s32)dst & 7)) {
1081
#pragma pipeloop(0)
1082
            for (; dst <= (dst_end - 2*4); dst += 2*4) {
1083
                dd = vis_freg_pair(((mlib_f32*)pixLut)[src[0]],
1084
                                   ((mlib_f32*)pixLut)[src[1]]);
1085
                ARGB2ABGR_DB(dd)
1086
                *(mlib_d64*)dst = dd;
1087
                src += 2;
1088
            }
1089
        } else {
1090
            mlib_d64 *dp;
1091

1092
            dp = vis_alignaddr(dst, 0);
1093
            dd = vis_faligndata(dp[0], dp[0]);
1094
            vis_alignaddrl(dst, 0);
1095

1096
#pragma pipeloop(0)
1097
            for (; dst <= (dst_end - 2*4); dst += 2*4) {
1098
                d_old = dd;
1099
                dd = vis_freg_pair(((mlib_f32*)pixLut)[src[0]],
1100
                                   ((mlib_f32*)pixLut)[src[1]]);
1101
                ARGB2ABGR_DB(dd)
1102
                *dp++ = vis_faligndata(d_old, dd);
1103
                src += 2;
1104
            }
1105

1106
            vis_pst_8(vis_faligndata(dd, dd), dp, vis_edge8(dp, dst - 1));
1107
        }
1108

1109
        while (dst < dst_end) {
1110
            x = pixLut[*src++];
1111
            dst[0] = x >> 24;
1112
            dst[1] = x;
1113
            dst[2] = x >> 8;
1114
            dst[3] = x >> 16;
1115
            dst += 4;
1116
        }
1117

1118
        PTR_ADD(dstBase, dstScan);
1119
        PTR_ADD(srcBase, srcScan);
1120
    }
1121
}
1122

1123
/***************************************************************/
1124

1125
void ADD_SUFF(ByteIndexedBmToFourByteAbgrXparOver)(BLIT_PARAMS)
1126
{
1127
    jint *pixLut = pSrcInfo->lutBase;
1128
    mlib_s32 dstScan = pDstInfo->scanStride;
1129
    mlib_s32 srcScan = pSrcInfo->scanStride;
1130
    mlib_d64 dd, dzero;
1131
    mlib_s32 i, j, x, mask;
1132

1133
/*  if (!(((mlib_s32)dstBase | dstScan) & 3)) {
1134
    ADD_SUFF(ByteIndexedToIntAbgrConvert)(BLIT_CALL_PARAMS);
1135
    return;
1136
    }*/
1137

1138
    if (width < 8) {
1139
        for (j = 0; j < height; j++) {
1140
            mlib_u8 *src = srcBase;
1141
            mlib_u8 *dst = dstBase;
1142

1143
            for (i = 0; i < width; i++) {
1144
                x = pixLut[src[i]];
1145
                if (x < 0) {
1146
                    dst[4*i    ] = x >> 24;
1147
                    dst[4*i + 1] = x;
1148
                    dst[4*i + 2] = x >> 8;
1149
                    dst[4*i + 3] = x >> 16;
1150
                }
1151
            }
1152

1153
            PTR_ADD(dstBase, dstScan);
1154
            PTR_ADD(srcBase, srcScan);
1155
        }
1156
        return;
1157
    }
1158

1159
    if (srcScan == width && dstScan == 4*width) {
1160
        width *= height;
1161
        height = 1;
1162
    }
1163

1164
    BMASK_FOR_ARGB
1165

1166
    dzero = vis_fzero();
1167

1168
    for (j = 0; j < height; j++) {
1169
        mlib_u8 *src = srcBase;
1170
        mlib_u8 *dst = dstBase;
1171
        mlib_u8 *dst_end;
1172

1173
        dst_end = dst + 4*width;
1174

1175
        if (!((mlib_s32)dst & 7)) {
1176
#pragma pipeloop(0)
1177
            for (; dst <= (dst_end - 2*4); dst += 2*4) {
1178
                dd = vis_freg_pair(((mlib_f32*)pixLut)[src[0]],
1179
                                   ((mlib_f32*)pixLut)[src[1]]);
1180
                mask = vis_fcmplt32(dd, dzero);
1181
                ARGB2ABGR_DB(dd)
1182
                vis_pst_32(dd, dst, mask);
1183
                src += 2;
1184
            }
1185
        }
1186

1187
        while (dst < dst_end) {
1188
            x = pixLut[*src++];
1189
            if (x < 0) {
1190
                dst[0] = x >> 24;
1191
                dst[1] = x;
1192
                dst[2] = x >> 8;
1193
                dst[3] = x >> 16;
1194
            }
1195
            dst += 4;
1196
        }
1197

1198
        PTR_ADD(dstBase, dstScan);
1199
        PTR_ADD(srcBase, srcScan);
1200
    }
1201
}
1202

1203
/***************************************************************/
1204

1205
void ADD_SUFF(ByteIndexedBmToFourByteAbgrXparBgCopy)(BCOPY_PARAMS)
1206
{
1207
    jint *pixLut = pSrcInfo->lutBase;
1208
    mlib_s32 dstScan = pDstInfo->scanStride;
1209
    mlib_s32 srcScan = pSrcInfo->scanStride;
1210
    mlib_d64 dd, dzero, d_bgpixel;
1211
    mlib_s32 i, j, x, mask;
1212
    mlib_s32 bgpix0 = bgpixel;
1213
    mlib_s32 bgpix1 = bgpixel >> 8;
1214
    mlib_s32 bgpix2 = bgpixel >> 16;
1215
    mlib_s32 bgpix3 = bgpixel >> 24;
1216

1217
    if (width < 8) {
1218
        for (j = 0; j < height; j++) {
1219
            mlib_u8 *src = srcBase;
1220
            mlib_u8 *dst = dstBase;
1221

1222
            for (i = 0; i < width; i++) {
1223
                x = pixLut[src[i]];
1224
                if (x < 0) {
1225
                    dst[4*i    ] = x >> 24;
1226
                    dst[4*i + 1] = x;
1227
                    dst[4*i + 2] = x >> 8;
1228
                    dst[4*i + 3] = x >> 16;
1229
                } else {
1230
                    dst[4*i    ] = bgpix0;
1231
                    dst[4*i + 1] = bgpix1;
1232
                    dst[4*i + 2] = bgpix2;
1233
                    dst[4*i + 3] = bgpix3;
1234
                }
1235
            }
1236

1237
            PTR_ADD(dstBase, dstScan);
1238
            PTR_ADD(srcBase, srcScan);
1239
        }
1240
        return;
1241
    }
1242

1243
    if (srcScan == width && dstScan == 4*width) {
1244
        width *= height;
1245
        height = 1;
1246
    }
1247

1248
    BMASK_FOR_ARGB
1249

1250
    dzero = vis_fzero();
1251
    d_bgpixel = vis_freg_pair(vis_ldfa_ASI_PL(&bgpixel),
1252
                              vis_ldfa_ASI_PL(&bgpixel));
1253

1254
    for (j = 0; j < height; j++) {
1255
        mlib_u8 *src = srcBase;
1256
        mlib_u8 *dst = dstBase;
1257
        mlib_u8 *dst_end;
1258

1259
        dst_end = dst + 4*width;
1260

1261
        if (!((mlib_s32)dst & 7)) {
1262
#pragma pipeloop(0)
1263
            for (; dst <= (dst_end - 2*4); dst += 2*4) {
1264
                dd = vis_freg_pair(((mlib_f32*)pixLut)[src[0]],
1265
                                   ((mlib_f32*)pixLut)[src[1]]);
1266
                mask = vis_fcmplt32(dd, dzero);
1267
                ARGB2ABGR_DB(dd)
1268
                *(mlib_d64*)dst = d_bgpixel;
1269
                vis_pst_32(dd, dst, mask);
1270
                src += 2;
1271
            }
1272
        }
1273

1274
        while (dst < dst_end) {
1275
            x = pixLut[*src++];
1276
            if (x < 0) {
1277
                dst[0] = x >> 24;
1278
                dst[1] = x;
1279
                dst[2] = x >> 8;
1280
                dst[3] = x >> 16;
1281
            } else {
1282
                dst[0] = bgpix0;
1283
                dst[1] = bgpix1;
1284
                dst[2] = bgpix2;
1285
                dst[3] = bgpix3;
1286
            }
1287
            dst += 4;
1288
        }
1289

1290
        PTR_ADD(dstBase, dstScan);
1291
        PTR_ADD(srcBase, srcScan);
1292
    }
1293
}
1294

1295
/***************************************************************/
1296

1297
void ADD_SUFF(ByteIndexedToFourByteAbgrScaleConvert)(SCALE_PARAMS)
1298
{
1299
    jint *pixLut = pSrcInfo->lutBase;
1300
    mlib_s32 dstScan = pDstInfo->scanStride;
1301
    mlib_s32 srcScan = pSrcInfo->scanStride;
1302
    mlib_d64 dd, d_old;
1303
    mlib_s32 i, j, x;
1304

1305
/*
1306
    if (!(((mlib_s32)dstBase | dstScan) & 3)) {
1307
        ADD_SUFF(ByteIndexedToIntAbgrScaleConvert)(SCALE_CALL_PARAMS);
1308
        return;
1309
    }
1310
*/
1311

1312
    if (width < 8) {
1313
        for (j = 0; j < height; j++) {
1314
            mlib_u8 *src = srcBase;
1315
            mlib_u8 *dst = dstBase;
1316
            mlib_s32 tmpsxloc = sxloc;
1317

1318
            PTR_ADD(src, (syloc >> shift) * srcScan);
1319

1320
            for (i = 0; i < width; i++) {
1321
                x = pixLut[src[tmpsxloc >> shift]];
1322
                tmpsxloc += sxinc;
1323
                dst[4*i    ] = x >> 24;
1324
                dst[4*i + 1] = x;
1325
                dst[4*i + 2] = x >> 8;
1326
                dst[4*i + 3] = x >> 16;
1327
            }
1328

1329
            PTR_ADD(dstBase, dstScan);
1330
            syloc += syinc;
1331
        }
1332
        return;
1333
    }
1334

1335
    BMASK_FOR_ARGB
1336

1337
    for (j = 0; j < height; j++) {
1338
        mlib_u8 *src = srcBase;
1339
        mlib_u8 *dst = dstBase;
1340
        mlib_u8 *dst_end;
1341
        mlib_s32 tmpsxloc = sxloc;
1342

1343
        PTR_ADD(src, (syloc >> shift) * srcScan);
1344

1345
        dst_end = dst + 4*width;
1346

1347
        if (!((mlib_s32)dst & 7)) {
1348
#pragma pipeloop(0)
1349
            for (; dst <= (dst_end - 2*4); dst += 2*4) {
1350
                dd = LOAD_2F32(pixLut, src[tmpsxloc >> shift],
1351
                                       src[(tmpsxloc + sxinc) >> shift]);
1352
                tmpsxloc += 2*sxinc;
1353
                ARGB2ABGR_DB(dd)
1354
                *(mlib_d64*)dst = dd;
1355
            }
1356
        } else {
1357
            mlib_d64 *dp;
1358

1359
            dp = vis_alignaddr(dst, 0);
1360
            dd = vis_faligndata(dp[0], dp[0]);
1361
            vis_alignaddrl(dst, 0);
1362

1363
#pragma pipeloop(0)
1364
            for (; dst <= (dst_end - 2*4); dst += 2*4) {
1365
                d_old = dd;
1366
                dd = LOAD_2F32(pixLut, src[tmpsxloc >> shift],
1367
                                       src[(tmpsxloc + sxinc) >> shift]);
1368
                tmpsxloc += 2*sxinc;
1369
                ARGB2ABGR_DB(dd)
1370
                *dp++ = vis_faligndata(d_old, dd);
1371
            }
1372

1373
            vis_pst_8(vis_faligndata(dd, dd), dp, vis_edge8(dp, dst - 1));
1374
        }
1375

1376
        while (dst < dst_end) {
1377
            x = pixLut[src[tmpsxloc >> shift]];
1378
            tmpsxloc += sxinc;
1379
            dst[0] = x >> 24;
1380
            dst[1] = x;
1381
            dst[2] = x >> 8;
1382
            dst[3] = x >> 16;
1383
            dst += 4;
1384
        }
1385

1386
        PTR_ADD(dstBase, dstScan);
1387
        syloc += syinc;
1388
    }
1389
}
1390

1391
/***************************************************************/
1392

1393
void ADD_SUFF(ByteIndexedBmToFourByteAbgrScaleXparOver)(SCALE_PARAMS)
1394
{
1395
    jint *pixLut = pSrcInfo->lutBase;
1396
    mlib_s32 dstScan = pDstInfo->scanStride;
1397
    mlib_s32 srcScan = pSrcInfo->scanStride;
1398
    mlib_d64 dd, dzero;
1399
    mlib_s32 i, j, x, mask;
1400

1401
/*
1402
    if (!(((mlib_s32)dstBase | dstScan) & 3)) {
1403
        ADD_SUFF(ByteIndexedToIntAbgrScaleConvert)(SCALE_CALL_PARAMS);
1404
        return;
1405
    }
1406
*/
1407

1408
    if (width < 8) {
1409
        for (j = 0; j < height; j++) {
1410
            mlib_u8 *src = srcBase;
1411
            mlib_u8 *dst = dstBase;
1412
            mlib_s32 tmpsxloc = sxloc;
1413

1414
            PTR_ADD(src, (syloc >> shift) * srcScan);
1415

1416
            for (i = 0; i < width; i++) {
1417
                x = pixLut[src[tmpsxloc >> shift]];
1418
                tmpsxloc += sxinc;
1419
                if (x < 0) {
1420
                    dst[4*i    ] = x >> 24;
1421
                    dst[4*i + 1] = x;
1422
                    dst[4*i + 2] = x >> 8;
1423
                    dst[4*i + 3] = x >> 16;
1424
                }
1425
            }
1426

1427
            PTR_ADD(dstBase, dstScan);
1428
            syloc += syinc;
1429
        }
1430
        return;
1431
    }
1432

1433
    BMASK_FOR_ARGB
1434

1435
    dzero = vis_fzero();
1436

1437
    for (j = 0; j < height; j++) {
1438
        mlib_u8 *src = srcBase;
1439
        mlib_u8 *dst = dstBase;
1440
        mlib_u8 *dst_end;
1441
        mlib_s32 tmpsxloc = sxloc;
1442

1443
        PTR_ADD(src, (syloc >> shift) * srcScan);
1444

1445
        dst_end = dst + 4*width;
1446

1447
        if (!((mlib_s32)dst & 7)) {
1448
#pragma pipeloop(0)
1449
            for (; dst <= (dst_end - 2*4); dst += 2*4) {
1450
                dd = LOAD_2F32(pixLut, src[tmpsxloc >> shift],
1451
                                       src[(tmpsxloc + sxinc) >> shift]);
1452
                tmpsxloc += 2*sxinc;
1453
                mask = vis_fcmplt32(dd, dzero);
1454
                ARGB2ABGR_DB(dd)
1455
                vis_pst_32(dd, dst, mask);
1456
            }
1457
        }
1458

1459
        while (dst < dst_end) {
1460
            x = pixLut[src[tmpsxloc >> shift]];
1461
            tmpsxloc += sxinc;
1462
            if (x < 0) {
1463
                dst[0] = x >> 24;
1464
                dst[1] = x;
1465
                dst[2] = x >> 8;
1466
                dst[3] = x >> 16;
1467
            }
1468
            dst += 4;
1469
        }
1470

1471
        PTR_ADD(dstBase, dstScan);
1472
        syloc += syinc;
1473
    }
1474
}
1475

1476
/***************************************************************/
1477

1478
void ADD_SUFF(IntArgbBmToFourByteAbgrScaleXparOver)(SCALE_PARAMS)
1479
{
1480
    mlib_s32 dstScan = pDstInfo->scanStride;
1481
    mlib_s32 srcScan = pSrcInfo->scanStride;
1482
    mlib_d64 dd, amask;
1483
    mlib_s32 i, j, x, mask;
1484

1485
    if (width < 16) {
1486
        for (j = 0; j < height; j++) {
1487
            mlib_s32 *src = srcBase;
1488
            mlib_u8  *dst = dstBase;
1489
            mlib_s32 tmpsxloc = sxloc;
1490

1491
            PTR_ADD(src, (syloc >> shift) * srcScan);
1492

1493
            for (i = 0; i < width; i++) {
1494
                x = src[tmpsxloc >> shift];
1495
                tmpsxloc += sxinc;
1496
                if (x >> 24) {
1497
                    dst[4*i    ] = 0xFF;
1498
                    dst[4*i + 1] = x;
1499
                    dst[4*i + 2] = x >> 8;
1500
                    dst[4*i + 3] = x >> 16;
1501
                }
1502
            }
1503

1504
            PTR_ADD(dstBase, dstScan);
1505
            syloc += syinc;
1506
        }
1507
        return;
1508
    }
1509

1510
    BMASK_FOR_ARGB
1511

1512
    amask = vis_to_double_dup(0xFF000000);
1513

1514
    for (j = 0; j < height; j++) {
1515
        mlib_s32 *src = srcBase;
1516
        mlib_u8  *dst = dstBase;
1517
        mlib_u8  *dst_end;
1518
        mlib_s32 tmpsxloc = sxloc;
1519

1520
        PTR_ADD(src, (syloc >> shift) * srcScan);
1521

1522
        dst_end = dst + 4*width;
1523

1524
        if (!((mlib_s32)dst & 7)) {
1525
#pragma pipeloop(0)
1526
            for (; dst <= (dst_end - 2*4); dst += 2*4) {
1527
                mlib_s32 *pp0 = src + (tmpsxloc >> shift);
1528
                mlib_s32 *pp1 = src + ((tmpsxloc + sxinc) >> shift);
1529
                dd = vis_freg_pair(*(mlib_f32*)pp0, *(mlib_f32*)pp1);
1530
                tmpsxloc += 2*sxinc;
1531
                ARGB2ABGR_DB(dd)
1532
                dd = vis_for(dd, amask);
1533
                mask = (((-*(mlib_u8*)pp0) >> 31) & 2) |
1534
                       (((-*(mlib_u8*)pp1) >> 31) & 1);
1535
                vis_pst_32(dd, dst, mask);
1536
            }
1537
        }
1538

1539
        while (dst < dst_end) {
1540
            x = src[tmpsxloc >> shift];
1541
            tmpsxloc += sxinc;
1542
            if (x >> 24) {
1543
                dst[0] = 0xFF;
1544
                dst[1] = x;
1545
                dst[2] = x >> 8;
1546
                dst[3] = x >> 16;
1547
            }
1548
            dst += 4;
1549
        }
1550

1551
        PTR_ADD(dstBase, dstScan);
1552
        syloc += syinc;
1553
    }
1554
}
1555

1556
/***************************************************************/
1557

1558
#ifdef MLIB_ADD_SUFF
1559
#pragma weak IntArgbBmToFourByteAbgrPreScaleXparOver_F =       \
1560
             IntArgbBmToFourByteAbgrScaleXparOver_F
1561
#else
1562
#pragma weak IntArgbBmToFourByteAbgrPreScaleXparOver =         \
1563
             IntArgbBmToFourByteAbgrScaleXparOver
1564
#endif
1565

1566
/***************************************************************/
1567

1568
void ADD_SUFF(FourByteAbgrToIntArgbScaleConvert)(SCALE_PARAMS)
1569
{
1570
    mlib_s32 dstScan = pDstInfo->scanStride;
1571
    mlib_s32 srcScan = pSrcInfo->scanStride;
1572
    mlib_s32 i, j;
1573

1574
    if (width < 16) {
1575
        for (j = 0; j < height; j++) {
1576
            mlib_u8  *src = srcBase;
1577
            mlib_s32 *dst = dstBase;
1578
            mlib_s32 tmpsxloc = sxloc;
1579

1580
            PTR_ADD(src, (syloc >> shift) * srcScan);
1581

1582
            for (i = 0; i < width; i++) {
1583
                mlib_u8 *pp = src + 4*(tmpsxloc >> shift);
1584
                *dst++ = (pp[0] << 24) | (pp[3] << 16) | (pp[2] << 8) | pp[1];
1585
                tmpsxloc += sxinc;
1586
            }
1587

1588
            PTR_ADD(dstBase, dstScan);
1589
            syloc += syinc;
1590
        }
1591
        return;
1592
    }
1593

1594
    BMASK_FOR_ARGB
1595

1596
    for (j = 0; j < height; j++) {
1597
        mlib_u8  *src = srcBase;
1598
        mlib_s32 *dst = dstBase;
1599
        mlib_s32 *dst_end = dst + width;
1600
        mlib_s32 tmpsxloc = sxloc;
1601
        mlib_s32 off;
1602
        mlib_d64 dd, dd0, dd1;
1603
        mlib_f32 *pp0, *pp1;
1604

1605
        PTR_ADD(src, (syloc >> shift) * srcScan);
1606

1607
        if ((mlib_s32)dst & 7) {
1608
            mlib_u8 *pp = src + 4*(tmpsxloc >> shift);
1609
            *dst++ = (pp[0] << 24) | (pp[3] << 16) | (pp[2] << 8) | pp[1];
1610
            tmpsxloc += sxinc;
1611
        }
1612

1613
        off = (mlib_s32)src & 3;
1614
        if (!off) {
1615
#pragma pipeloop(0)
1616
            for (; dst <= (dst_end - 2); dst += 2) {
1617
                pp0 = (mlib_f32*)src + (tmpsxloc >> shift);
1618
                pp1 = (mlib_f32*)src + ((tmpsxloc + sxinc) >> shift);
1619
                tmpsxloc += 2*sxinc;
1620
                dd = vis_freg_pair(pp0[0], pp1[0]);
1621
                ARGB2ABGR_DB(dd)
1622
                *(mlib_d64*)dst = dd;
1623
            }
1624
        } else {
1625
            vis_alignaddr(NULL, off);
1626
#pragma pipeloop(0)
1627
            for (; dst <= (dst_end - 2); dst += 2) {
1628
                pp0 = (mlib_f32*)(src - off) + (tmpsxloc >> shift);
1629
                pp1 = (mlib_f32*)(src - off) + ((tmpsxloc + sxinc) >> shift);
1630
                tmpsxloc += 2*sxinc;
1631
                dd0 = vis_freg_pair(pp0[0], pp0[1]);
1632
                dd1 = vis_freg_pair(pp1[0], pp1[1]);
1633
                dd0 = vis_faligndata(dd0, dd0);
1634
                dd1 = vis_faligndata(dd1, dd1);
1635
                ARGB2ABGR_FL2(dd, vis_read_hi(dd0), vis_read_hi(dd1))
1636
                *(mlib_d64*)dst = dd;
1637
            }
1638
        }
1639

1640
        if (dst < dst_end) {
1641
            mlib_u8 *pp = src + 4*(tmpsxloc >> shift);
1642
            *dst++ = (pp[0] << 24) | (pp[3] << 16) | (pp[2] << 8) | pp[1];
1643
            tmpsxloc += sxinc;
1644
        }
1645

1646
        PTR_ADD(dstBase, dstScan);
1647
        syloc += syinc;
1648
    }
1649
}
1650

1651
/***************************************************************/
1652

1653
void ADD_SUFF(IntArgbToFourByteAbgrScaleConvert)(SCALE_PARAMS)
1654
{
1655
    mlib_s32 dstScan = pDstInfo->scanStride;
1656
    mlib_s32 srcScan = pSrcInfo->scanStride;
1657
    mlib_s32 i, j;
1658
    mlib_s32 x;
1659

1660
    if (width < 16) {
1661
        for (j = 0; j < height; j++) {
1662
            mlib_s32 *src = srcBase;
1663
            mlib_u8  *dst = dstBase;
1664
            mlib_s32 tmpsxloc = sxloc;
1665

1666
            PTR_ADD(src, (syloc >> shift) * srcScan);
1667

1668
            for (i = 0; i < width; i++) {
1669
                x = src[tmpsxloc >> shift];
1670
                tmpsxloc += sxinc;
1671
                dst[4*i    ] = x >> 24;
1672
                dst[4*i + 1] = x;
1673
                dst[4*i + 2] = x >> 8;
1674
                dst[4*i + 3] = x >> 16;
1675
            }
1676

1677
            PTR_ADD(dstBase, dstScan);
1678
            syloc += syinc;
1679
        }
1680
        return;
1681
    }
1682

1683
    BMASK_FOR_ARGB
1684

1685
    for (j = 0; j < height; j++) {
1686
        mlib_s32 *src = srcBase;
1687
        mlib_u8  *dst = dstBase;
1688
        mlib_u8  *dst_end = dst + 4*width;
1689
        mlib_s32 tmpsxloc = sxloc;
1690
        mlib_d64 dd, d_old;
1691
        mlib_f32 *pp0, *pp1;
1692

1693
        PTR_ADD(src, (syloc >> shift) * srcScan);
1694

1695
        if (!((mlib_s32)dst & 3)) {
1696
            if ((mlib_s32)dst & 7) {
1697
                x = src[tmpsxloc >> shift];
1698
                tmpsxloc += sxinc;
1699
                dst[0] = x >> 24;
1700
                dst[1] = x;
1701
                dst[2] = x >> 8;
1702
                dst[3] = x >> 16;
1703
                dst += 4;
1704
            }
1705
#pragma pipeloop(0)
1706
            for (; dst <= (dst_end - 2*4); dst += 2*4) {
1707
                pp0 = (mlib_f32*)src + (tmpsxloc >> shift);
1708
                pp1 = (mlib_f32*)src + ((tmpsxloc + sxinc) >> shift);
1709
                tmpsxloc += 2*sxinc;
1710
                dd = vis_freg_pair(pp0[0], pp1[0]);
1711
                ARGB2ABGR_DB(dd)
1712
                *(mlib_d64*)dst = dd;
1713
            }
1714
        } else {
1715
            mlib_d64 *dp;
1716

1717
            dp = vis_alignaddr(dst, 0);
1718
            dd = vis_faligndata(dp[0], dp[0]);
1719
            vis_alignaddrl(dst, 0);
1720

1721
#pragma pipeloop(0)
1722
            for (; dst <= (dst_end - 2*4); dst += 2*4) {
1723
                d_old = dd;
1724
                pp0 = (mlib_f32*)src + (tmpsxloc >> shift);
1725
                pp1 = (mlib_f32*)src + ((tmpsxloc + sxinc) >> shift);
1726
                tmpsxloc += 2*sxinc;
1727
                dd = vis_freg_pair(pp0[0], pp1[0]);
1728
                ARGB2ABGR_DB(dd)
1729
                *dp++ = vis_faligndata(d_old, dd);
1730
            }
1731

1732
            vis_pst_8(vis_faligndata(dd, dd), dp, vis_edge8(dp, dst - 1));
1733
        }
1734

1735
        if (dst < dst_end) {
1736
            x = src[tmpsxloc >> shift];
1737
            tmpsxloc += sxinc;
1738
            dst[0] = x >> 24;
1739
            dst[1] = x;
1740
            dst[2] = x >> 8;
1741
            dst[3] = x >> 16;
1742
            dst += 4;
1743
        }
1744

1745
        PTR_ADD(dstBase, dstScan);
1746
        syloc += syinc;
1747
    }
1748
}
1749

1750
/***************************************************************/
1751

1752
void ADD_SUFF(IntRgbToFourByteAbgrScaleConvert)(SCALE_PARAMS)
1753
{
1754
    mlib_s32 dstScan = pDstInfo->scanStride;
1755
    mlib_s32 srcScan = pSrcInfo->scanStride;
1756
    mlib_s32 i, j;
1757
    mlib_s32 x;
1758
    mlib_d64 amask = vis_to_double_dup(0xFF000000);
1759

1760
    if (width < 16) {
1761
        for (j = 0; j < height; j++) {
1762
            mlib_s32 *src = srcBase;
1763
            mlib_u8  *dst = dstBase;
1764
            mlib_s32 tmpsxloc = sxloc;
1765

1766
            PTR_ADD(src, (syloc >> shift) * srcScan);
1767

1768
            for (i = 0; i < width; i++) {
1769
                x = src[tmpsxloc >> shift];
1770
                tmpsxloc += sxinc;
1771
                dst[4*i    ] = 0xFF;
1772
                dst[4*i + 1] = x;
1773
                dst[4*i + 2] = x >> 8;
1774
                dst[4*i + 3] = x >> 16;
1775
            }
1776

1777
            PTR_ADD(dstBase, dstScan);
1778
            syloc += syinc;
1779
        }
1780
        return;
1781
    }
1782

1783
    BMASK_FOR_ARGB
1784

1785
    for (j = 0; j < height; j++) {
1786
        mlib_s32 *src = srcBase;
1787
        mlib_u8  *dst = dstBase;
1788
        mlib_u8  *dst_end = dst + 4*width;
1789
        mlib_s32 tmpsxloc = sxloc;
1790
        mlib_d64 dd, d_old;
1791
        mlib_f32 *pp0, *pp1;
1792

1793
        PTR_ADD(src, (syloc >> shift) * srcScan);
1794

1795
        if (!((mlib_s32)dst & 3)) {
1796
            if ((mlib_s32)dst & 7) {
1797
                x = src[tmpsxloc >> shift];
1798
                tmpsxloc += sxinc;
1799
                dst[0] = 0xFF;
1800
                dst[1] = x;
1801
                dst[2] = x >> 8;
1802
                dst[3] = x >> 16;
1803
                dst += 4;
1804
            }
1805
#pragma pipeloop(0)
1806
            for (; dst <= (dst_end - 2*4); dst += 2*4) {
1807
                pp0 = (mlib_f32*)src + (tmpsxloc >> shift);
1808
                pp1 = (mlib_f32*)src + ((tmpsxloc + sxinc) >> shift);
1809
                tmpsxloc += 2*sxinc;
1810
                dd = vis_freg_pair(pp0[0], pp1[0]);
1811
                RGB2ABGR_DB(dd)
1812
                *(mlib_d64*)dst = dd;
1813
            }
1814
        } else {
1815
            mlib_d64 *dp;
1816

1817
            dp = vis_alignaddr(dst, 0);
1818
            dd = vis_faligndata(dp[0], dp[0]);
1819
            vis_alignaddrl(dst, 0);
1820

1821
#pragma pipeloop(0)
1822
            for (; dst <= (dst_end - 2*4); dst += 2*4) {
1823
                d_old = dd;
1824
                pp0 = (mlib_f32*)src + (tmpsxloc >> shift);
1825
                pp1 = (mlib_f32*)src + ((tmpsxloc + sxinc) >> shift);
1826
                tmpsxloc += 2*sxinc;
1827
                dd = vis_freg_pair(pp0[0], pp1[0]);
1828
                RGB2ABGR_DB(dd)
1829
                *dp++ = vis_faligndata(d_old, dd);
1830
            }
1831

1832
            vis_pst_8(vis_faligndata(dd, dd), dp, vis_edge8(dp, dst - 1));
1833
        }
1834

1835
        if (dst < dst_end) {
1836
            x = src[tmpsxloc >> shift];
1837
            tmpsxloc += sxinc;
1838
            dst[0] = 0xFF;
1839
            dst[1] = x;
1840
            dst[2] = x >> 8;
1841
            dst[3] = x >> 16;
1842
            dst += 4;
1843
        }
1844

1845
        PTR_ADD(dstBase, dstScan);
1846
        syloc += syinc;
1847
    }
1848
}
1849

1850
/***************************************************************/
1851

1852
void ADD_SUFF(FourByteAbgrDrawGlyphListAA)(SurfaceDataRasInfo * pRasInfo,
1853
                                           ImageRef *glyphs,
1854
                                           jint totalGlyphs,
1855
                                           jint fgpixel, jint argbcolor,
1856
                                           jint clipLeft, jint clipTop,
1857
                                           jint clipRight, jint clipBottom,
1858
                                           NativePrimitive * pPrim,
1859
                                           CompositeInfo * pCompInfo)
1860
{
1861
    mlib_d64 buff[BUFF_SIZE/2];
1862
    void     *pbuff = buff;
1863
    mlib_s32 glyphCounter;
1864
    mlib_s32 scan = pRasInfo->scanStride;
1865
    mlib_u8  *dstBase;
1866
    mlib_s32 i, j;
1867
    mlib_d64 dmix0, dmix1, dd, d0, d1, e0, e1, fgpixel_d;
1868
    mlib_d64 done, done16, d_half;
1869
    mlib_s32 pix, mask;
1870
    mlib_f32 fgpixel_f, srcG_f;
1871
    mlib_s32 max_width = BUFF_SIZE;
1872

1873
    done = vis_to_double_dup(0x7fff7fff);
1874
    done16 = vis_to_double_dup(0x7fff);
1875
    d_half = vis_to_double_dup((1 << (16 + 6)) | (1 << 6));
1876

1877
    fgpixel_f = vis_ldfa_ASI_PL(&fgpixel);
1878
    fgpixel_d = vis_freg_pair(fgpixel_f, fgpixel_f);
1879
    srcG_f = vis_to_float(argbcolor);
1880
    ARGB2ABGR_FL(srcG_f)
1881

1882
    vis_write_gsr(0 << 3);
1883

1884
    for (glyphCounter = 0; glyphCounter < totalGlyphs; glyphCounter++) {
1885
        const jubyte *pixels;
1886
        unsigned int rowBytes;
1887
        int left, top;
1888
        int width, height;
1889
        int right, bottom;
1890

1891
        pixels = (const jubyte *) glyphs[glyphCounter].pixels;
1892

1893
        if (!pixels) continue;
1894

1895
        left = glyphs[glyphCounter].x;
1896
        top = glyphs[glyphCounter].y;
1897
        width = glyphs[glyphCounter].width;
1898
        height = glyphs[glyphCounter].height;
1899
        rowBytes = width;
1900
        right = left + width;
1901
        bottom = top + height;
1902
        if (left < clipLeft) {
1903
            pixels += clipLeft - left;
1904
            left = clipLeft;
1905
        }
1906
        if (top < clipTop) {
1907
            pixels += (clipTop - top) * rowBytes;
1908
            top = clipTop;
1909
        }
1910
        if (right > clipRight) {
1911
            right = clipRight;
1912
        }
1913
        if (bottom > clipBottom) {
1914
            bottom = clipBottom;
1915
        }
1916
        if (right <= left || bottom <= top) {
1917
            continue;
1918
        }
1919
        width = right - left;
1920
        height = bottom - top;
1921

1922
        dstBase = pRasInfo->rasBase;
1923
        PTR_ADD(dstBase, top*scan + 4*left);
1924

1925
        if (((mlib_s32)dstBase | scan) & 3) {
1926
            if (width > max_width) {
1927
                if (pbuff != buff) {
1928
                    mlib_free(pbuff);
1929
                }
1930
                pbuff = mlib_malloc(width*sizeof(mlib_s32));
1931
                if (pbuff == NULL) return;
1932
                max_width = width;
1933
            }
1934
        }
1935

1936
        for (j = 0; j < height; j++) {
1937
            mlib_u8  *src = (void*)pixels;
1938
            mlib_s32 *dst, *dst_end;
1939
            mlib_u8 *dst_start;
1940

1941
            if ((mlib_s32)dstBase & 3) {
1942
                COPY_NA(dstBase, pbuff, width*sizeof(mlib_s32));
1943
                dst = pbuff;
1944
            } else {
1945
                dst = (void*)dstBase;
1946
            }
1947
            dst_start = (void*)dst;
1948
            dst_end = dst + width;
1949

1950
            /* Need to reset the GSR from the values set by the
1951
             * convert call near the end of this loop.
1952
             */
1953
            vis_write_gsr(7 << 0);
1954

1955
            if ((mlib_s32)dst & 7) {
1956
                pix = *src++;
1957
                dd = vis_fpadd16(MUL8_VIS(srcG_f, pix), d_half);
1958
                dd = vis_fpadd16(MUL8_VIS(*(mlib_f32*)dst, 255 - pix), dd);
1959
                *(mlib_f32*)dst = vis_fpack16(dd);
1960
                if (pix == 255) *(mlib_f32*)dst = vis_read_hi(fgpixel_d);
1961
                dst++;
1962
            }
1963

1964
#pragma pipeloop(0)
1965
            for (; dst <= (dst_end - 2); dst += 2) {
1966
                dmix0 = vis_freg_pair(((mlib_f32 *)vis_mul8s_tbl)[src[0]],
1967
                                      ((mlib_f32 *)vis_mul8s_tbl)[src[1]]);
1968
                mask = vis_fcmplt32(dmix0, done16);
1969
                dmix1 = vis_fpsub16(done, dmix0);
1970
                src += 2;
1971

1972
                dd = *(mlib_d64*)dst;
1973
                d0 = vis_fmul8x16al(srcG_f, vis_read_hi(dmix0));
1974
                d1 = vis_fmul8x16al(srcG_f, vis_read_lo(dmix0));
1975
                e0 = vis_fmul8x16al(vis_read_hi(dd), vis_read_hi(dmix1));
1976
                e1 = vis_fmul8x16al(vis_read_lo(dd), vis_read_lo(dmix1));
1977
                d0 = vis_fpadd16(vis_fpadd16(d0, d_half), e0);
1978
                d1 = vis_fpadd16(vis_fpadd16(d1, d_half), e1);
1979
                dd = vis_fpack16_pair(d0, d1);
1980

1981
                *(mlib_d64*)dst = fgpixel_d;
1982
                vis_pst_32(dd, dst, mask);
1983
            }
1984

1985
            while (dst < dst_end) {
1986
                pix = *src++;
1987
                dd = vis_fpadd16(MUL8_VIS(srcG_f, pix), d_half);
1988
                dd = vis_fpadd16(MUL8_VIS(*(mlib_f32*)dst, 255 - pix), dd);
1989
                *(mlib_f32*)dst = vis_fpack16(dd);
1990
                if (pix == 255) *(mlib_f32*)dst = vis_read_hi(fgpixel_d);
1991
                dst++;
1992
            }
1993

1994
            ADD_SUFF(IntArgbPreToIntArgbConvert)(dst_start, dst_start,
1995
                                                 width, 1,
1996
                                                 pRasInfo, pRasInfo,
1997
                                                 pPrim, pCompInfo);
1998

1999
            if ((mlib_s32)dstBase & 3) {
2000
                COPY_NA(dst_start, dstBase, width*sizeof(mlib_s32));
2001
            }
2002

2003
            PTR_ADD(dstBase, scan);
2004
            pixels += rowBytes;
2005
        }
2006
    }
2007

2008
    if (pbuff != buff) {
2009
        mlib_free(pbuff);
2010
    }
2011
}
2012

2013
/***************************************************************/
2014

2015
#endif /* JAVA2D_NO_MLIB */
2016

2017
Product

Resources

Company
