JDK14/Java14源码在线阅读

/*
 * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

#if !defined(JAVA2D_NO_MLIB) || defined(MLIB_ADD_SUFF)

#include <vis_proto.h>
#include "java2d_Mlib.h"

/***************************************************************/

#define ARGB_XOR(index, chan)                                                \
{                                                                            \
    jint srcpixel = src_ptr[index];                                          \
    jint neg_mask = srcpixel >> 31;                                          \
    dst_ptr[index] ^= (srcpixel ^ xorpixel) & (neg_mask &~ alphamask);       \
}

/***************************************************************/

#define BGR_XOR(index, chan)                                                 \
{                                                                            \
    jint srcpixel = src_ptr[index];                                          \
    jint neg_mask = srcpixel >> 31;                                          \
    srcpixel = (srcpixel << 16) | (srcpixel & 0xff00) |                      \
               ((srcpixel >> 16) & 0xff);                                    \
    dst_ptr[index] ^= (srcpixel ^ xorpixel) & (neg_mask &~ alphamask);       \
}

/***************************************************************/

#define ARGB_BM_XOR(index, chan)                                             \
{                                                                            \
    jint srcpixel = src_ptr[index];                                          \
    jint neg_mask = srcpixel >> 31;                                          \
    srcpixel |= 0xFF000000;                                                  \
    dst_ptr[index] ^= (srcpixel ^ xorpixel) & (neg_mask &~ alphamask);       \
}

/***************************************************************/

#define RGBX_XOR(index, chan)                          \
{                                                      \
    jint srcpixel = src_ptr[index];                    \
    jint neg_mask = srcpixel >> 31;                    \
    dst_ptr[index] ^= ((srcpixel << 8) ^ xorpixel) &   \
                      (neg_mask &~ alphamask);         \
}

/***************************************************************/

#define ARGB_to_GBGR_FL2(dst, src0, src1) {                    \
    mlib_d64 t0, t1, t2;                                       \
    t0 = vis_fpmerge(src0, src1);                              \
    t1 = vis_fpmerge(vis_read_lo(t0), vis_read_hi(t0));        \
    t2 = vis_fpmerge(vis_read_lo(t0), vis_read_lo(t0));        \
    dst = vis_fpmerge(vis_read_hi(t2), vis_read_lo(t1));       \
}

/***************************************************************/

#ifdef MLIB_ADD_SUFF
#pragma weak IntArgbToIntRgbXorBlit_F = IntArgbToIntArgbXorBlit_F
#else
#pragma weak IntArgbToIntRgbXorBlit   = IntArgbToIntArgbXorBlit
#endif

/***************************************************************/

void ADD_SUFF(IntArgbToIntArgbXorBlit)(BLIT_PARAMS)
{
    mlib_s32 dstScan = pDstInfo->scanStride;
    mlib_s32 srcScan = pSrcInfo->scanStride;
    mlib_s32 xorpixel = pCompInfo->details.xorPixel;
    mlib_s32 alphamask = pCompInfo->alphaMask;
    mlib_s32 i, j;
    mlib_d64 res, xorpixel64, alphamask64, dzero;

    if (width < 8) {
        LOOP_DST_SRC(AnyInt, 1, dstBase, dstScan, srcBase, srcScan, ARGB_XOR);
        return;
    }

    if (dstScan == 4*width && srcScan == dstScan) {
        width *= height;
        height = 1;
    }

    xorpixel64 = vis_to_double_dup(xorpixel);
    alphamask64 = vis_to_double_dup(alphamask);
    dzero = vis_fzero();

    for (j = 0; j < height; j++) {
        mlib_s32 *dst_ptr = dstBase;
        mlib_s32 *src_ptr = srcBase;
        mlib_s32 size = width;

        if ((mlib_s32)dst_ptr & 7) {
            ARGB_XOR(0, 0);
            dst_ptr++;
            src_ptr++;
            size--;
        }

#pragma pipeloop(0)
        for (i = 0; i <= size - 2; i += 2) {
            mlib_s32 neg_mask;
            mlib_f32 *pp0 = (mlib_f32*)src_ptr + i;
            mlib_f32 *pp1 = (mlib_f32*)src_ptr + i + 1;
            neg_mask = (((*(mlib_u8*)pp0) >> 6) & 2) | ((*(mlib_u8*)pp1) >> 7);
            res = vis_freg_pair(*pp0, *pp1);
            res = vis_fxor(res, xorpixel64);
            res = vis_fandnot(alphamask64, res);
            res = vis_fxor(res, *(mlib_d64*)(dst_ptr + i));
            vis_pst_32(res, dst_ptr + i, neg_mask);
        }

        if (i < size) {
            ARGB_XOR(i, 0);
        }

        PTR_ADD(dstBase, dstScan);
        PTR_ADD(srcBase, srcScan);
    }
}

/***************************************************************/

void ADD_SUFF(IntArgbToIntBgrXorBlit)(BLIT_PARAMS)
{
    mlib_s32 dstScan = pDstInfo->scanStride;
    mlib_s32 srcScan = pSrcInfo->scanStride;
    mlib_s32 xorpixel = pCompInfo->details.xorPixel;
    mlib_s32 alphamask = pCompInfo->alphaMask;
    mlib_s32 i, j;
    mlib_d64 res, xorpixel64, alphamask64, dzero;

    if (width < 8) {
        LOOP_DST_SRC(AnyInt, 1, dstBase, dstScan, srcBase, srcScan, BGR_XOR);
        return;
    }

    if (dstScan == 4*width && srcScan == dstScan) {
        width *= height;
        height = 1;
    }

    xorpixel64 = vis_to_double_dup(xorpixel);
    alphamask64 = vis_to_double_dup(alphamask);
    dzero = vis_fzero();

    for (j = 0; j < height; j++) {
        mlib_s32 *dst_ptr = dstBase;
        mlib_s32 *src_ptr = srcBase;
        mlib_s32 size = width;

        if ((mlib_s32)dst_ptr & 7) {
            BGR_XOR(0, 0);
            dst_ptr++;
            src_ptr++;
            size--;
        }

#pragma pipeloop(0)
        for (i = 0; i <= size - 2; i += 2) {
            mlib_s32 neg_mask;
            mlib_f32 *pp0 = (mlib_f32*)src_ptr + i;
            mlib_f32 *pp1 = (mlib_f32*)src_ptr + i + 1;
            neg_mask = (((*(mlib_u8*)pp0) >> 6) & 2) | ((*(mlib_u8*)pp1) >> 7);
            ARGB_to_GBGR_FL2(res, *pp0, *pp1);
            res = vis_fxor(res, xorpixel64);
            res = vis_fandnot(alphamask64, res);
            res = vis_fxor(res, *(mlib_d64*)(dst_ptr + i));
            vis_pst_32(res, dst_ptr + i, neg_mask);
        }

        if (i < size) {
            BGR_XOR(i, 0);
        }

        PTR_ADD(dstBase, dstScan);
        PTR_ADD(srcBase, srcScan);
    }
}

/***************************************************************/

void ADD_SUFF(IntArgbToIntArgbBmXorBlit)(BLIT_PARAMS)
{
    mlib_s32 dstScan = pDstInfo->scanStride;
    mlib_s32 srcScan = pSrcInfo->scanStride;
    mlib_s32 xorpixel = pCompInfo->details.xorPixel;
    mlib_s32 alphamask = pCompInfo->alphaMask;
    mlib_s32 i, j, neg_mask;
    mlib_d64 res, xorpixel64, alphamask64, dzero, dFF;

    if (width < 8) {
        LOOP_DST_SRC(AnyInt, 1, dstBase, dstScan, srcBase, srcScan,
                     ARGB_BM_XOR);
        return;
    }

    if (dstScan == 4*width && srcScan == dstScan) {
        width *= height;
        height = 1;
    }

    xorpixel64 = vis_to_double_dup(xorpixel);
    alphamask64 = vis_to_double_dup(alphamask);
    dzero = vis_fzero();
    dFF = vis_to_double_dup(0xFF000000);

    for (j = 0; j < height; j++) {
        mlib_s32 *dst_ptr = dstBase;
        mlib_s32 *src_ptr = srcBase;
        mlib_s32 size = width;

        if ((mlib_s32)dst_ptr & 7) {
            ARGB_BM_XOR(0, 0);
            dst_ptr++;
            src_ptr++;
            size--;
        }

#pragma pipeloop(0)
        for (i = 0; i <= size - 2; i += 2) {
            mlib_s32 neg_mask;
            mlib_f32 *pp0 = (mlib_f32*)src_ptr + i;
            mlib_f32 *pp1 = (mlib_f32*)src_ptr + i + 1;
            neg_mask = (((*(mlib_u8*)pp0) >> 6) & 2) | ((*(mlib_u8*)pp1) >> 7);
            res = vis_freg_pair(*pp0, *pp1);
            res = vis_for(res, dFF);
            res = vis_fxor(res, xorpixel64);
            res = vis_fandnot(alphamask64, res);
            res = vis_fxor(res, *(mlib_d64*)(dst_ptr + i));
            vis_pst_32(res, dst_ptr + i, neg_mask);
        }

        if (i < size) {
            ARGB_BM_XOR(i, 0);
        }

        PTR_ADD(dstBase, dstScan);
        PTR_ADD(srcBase, srcScan);
    }
}

/***************************************************************/

void ADD_SUFF(IntArgbToIntRgbxXorBlit)(BLIT_PARAMS)
{
    mlib_s32 dstScan = pDstInfo->scanStride;
    mlib_s32 srcScan = pSrcInfo->scanStride;
    mlib_s32 xorpixel = pCompInfo->details.xorPixel;
    mlib_s32 alphamask = pCompInfo->alphaMask;
    mlib_s32 i, j, neg_mask;
    mlib_d64 res, xorpixel64, alphamask64, rgbx_mask, dzero;

    if (width < 8) {
        LOOP_DST_SRC(AnyInt, 1, dstBase, dstScan, srcBase, srcScan, RGBX_XOR);
        return;
    }

    if (dstScan == 4*width && srcScan == dstScan) {
        width *= height;
        height = 1;
    }

    xorpixel64 = vis_to_double_dup(xorpixel);
    alphamask64 = vis_to_double_dup(alphamask);
    rgbx_mask = vis_to_double_dup(0xFFFFFF00);
    dzero = vis_fzero();

    vis_alignaddr(NULL, 1);

    for (j = 0; j < height; j++) {
        mlib_s32 *dst_ptr = dstBase;
        mlib_s32 *src_ptr = srcBase;
        mlib_s32 size = width;

        if ((mlib_s32)dst_ptr & 7) {
            RGBX_XOR(0, 0);
            dst_ptr++;
            src_ptr++;
            size--;
        }

#pragma pipeloop(0)
        for (i = 0; i <= size - 2; i += 2) {
            mlib_s32 neg_mask;
            mlib_f32 *pp0 = (mlib_f32*)src_ptr + i;
            mlib_f32 *pp1 = (mlib_f32*)src_ptr + i + 1;
            neg_mask = (((*(mlib_u8*)pp0) >> 6) & 2) | ((*(mlib_u8*)pp1) >> 7);
            res = vis_freg_pair(*pp0, *pp1);
            res = vis_fand(vis_faligndata(res, res), rgbx_mask);
            res = vis_fxor(res, xorpixel64);
            res = vis_fandnot(alphamask64, res);
            res = vis_fxor(res, *(mlib_d64*)(dst_ptr + i));
            vis_pst_32(res, dst_ptr + i, neg_mask);
        }

        if (i < size) {
            RGBX_XOR(i, 0);
        }

        PTR_ADD(dstBase, dstScan);
        PTR_ADD(srcBase, srcScan);
    }
}

/***************************************************************/

void ADD_SUFF(IntArgbToFourByteAbgrPreXorBlit)(BLIT_PARAMS)
{
    jint   xorpixel = pCompInfo->details.xorPixel;
    juint  alphamask = pCompInfo->alphaMask;
    jint   xor0, xor1, xor2, xor3;
    jint   mask0, mask1, mask2, mask3;
    jint   *pSrc = srcBase;
    jubyte *pDst = dstBase;
    jint   srcScan = pSrcInfo->scanStride;
    jint   dstScan = pDstInfo->scanStride;


/**代码未完, 请加载全部代码(NowJava.com).**/
展开阅读全文

关注时代Java

关注时代Java