/*
 * 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 "vis_AlphaMacros.h"

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

#define STORE_INT      \
    *dst = fgpixel

#define STORE_D64(TSIZE, dst, mask)    \
    vis_pst_##TSIZE(fgpixel_d, dst, mask)

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

#define INIT_FG

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

#define DEF_GLYPH(TSIZE)                                       \
    const jubyte *pixels;                                      \
    unsigned int rowBytes;                                     \
    int left, top;                                             \
    int width, height;                                         \
    int right, bottom;                                         \
                                                               \
    pixels = (const jubyte *) glyphs[glyphCounter].pixels;     \
                                                               \
    if (!pixels) continue;                                     \
                                                               \
    left = glyphs[glyphCounter].x;                             \
    top = glyphs[glyphCounter].y;                              \
    width = glyphs[glyphCounter].width;                        \
    height = glyphs[glyphCounter].height;                      \
    rowBytes = width;                                          \
    right = left + width;                                      \
    bottom = top + height;                                     \
    if (left < clipLeft) {                                     \
        pixels += clipLeft - left;                             \
        left = clipLeft;                                       \
    }                                                          \
    if (top < clipTop) {                                       \
        pixels += (clipTop - top) * rowBytes;                  \
        top = clipTop;                                         \
    }                                                          \
    if (right > clipRight) {                                   \
        right = clipRight;                                     \
    }                                                          \
    if (bottom > clipBottom) {                                 \
        bottom = clipBottom;                                   \
    }                                                          \
    if (right <= left || bottom <= top) {                      \
        continue;                                              \
    }                                                          \
    width = right - left;                                      \
    height = bottom - top;                                     \
                                                               \
    dstBase = pRasInfo->rasBase;                               \
    PTR_ADD(dstBase, top*scan + TSIZE*left)

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

void ADD_SUFF(AnyByteDrawGlyphList)(GLYPH_LIST_PARAMS)
{
    mlib_s32 glyphCounter;
    mlib_s32 scan = pRasInfo->scanStride;
    mlib_u8  *dstBase;
    mlib_s32 j;
    mlib_d64 fgpixel_d;
    mlib_d64 dzero;
    mlib_s32 pix, mask0, mask1, mask_h, mask_l, off;
    mlib_f32 fzero;

    INIT_FG

    fzero = vis_fzeros();
    dzero = vis_fzero();
    D64_FROM_U8x8(fgpixel_d, fgpixel);

    for (glyphCounter = 0; glyphCounter < totalGlyphs; glyphCounter++) {
        DEF_GLYPH(1);

        for (j = 0; j < height; j++) {
            mlib_u8 *src = (void*)pixels;
            mlib_u8 *dst, *dst_end;
            mlib_d64 ss, s0, s1;

            dst = (void*)dstBase;
            dst_end = dst + width;

            while (((mlib_s32)dst & 7) && (dst < dst_end)) {
                pix = *src++;
                if (pix) STORE_INT;
                dst++;
            }

            off = (mlib_s32)src & 7;
            ss = *(mlib_d64*)(src - off);
            mask_h = vis_fcmpne16(vis_fpmerge(vis_read_hi(ss), fzero), dzero);
            mask_l = vis_fcmpne16(vis_fpmerge(vis_read_lo(ss), fzero), dzero);
            mask1 = (mask_h << 4) | mask_l;

#pragma pipeloop(0)
            for (; dst <= (dst_end - 8); dst += 8) {
                mask0 = mask1;
                src += 8;
                ss = *(mlib_d64*)(src - off);
                s0 = vis_fpmerge(vis_read_hi(ss), fzero);
                s1 = vis_fpmerge(vis_read_lo(ss), fzero);
                mask_h = vis_fcmpne16(s0, dzero);
                mask_l = vis_fcmpne16(s1, dzero);
                mask1 = (mask_h << 4) | mask_l;
                STORE_D64(8, dst, (mask0 << off) | (mask1 >> (8 - off)));
            }

            while (dst < dst_end) {
                pix = *src++;
                if (pix) STORE_INT;
                dst++;
            }

            PTR_ADD(dstBase, scan);
            pixels += rowBytes;
        }
    }
}

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

void ADD_SUFF(AnyShortDrawGlyphList)(GLYPH_LIST_PARAMS)
{
    mlib_s32 glyphCounter;
    mlib_s32 scan = pRasInfo->scanStride;
    mlib_u8  *dstBase;
    mlib_s32 j;
    mlib_d64 fgpixel_d;
    mlib_d64 dzero;
    mlib_s32 pix, mask0, mask1, off;
    mlib_f32 fzero;

    INIT_FG

    fzero = vis_fzeros();
    dzero = vis_fzero();
    D64_FROM_U16x4(fgpixel_d, fgpixel);

    for (glyphCounter = 0; glyphCounter < totalGlyphs; glyphCounter++) {
        DEF_GLYPH(2);

        for (j = 0; j < height; j++) {
            mlib_u8 *src = (void*)pixels;
            mlib_u16 *dst, *dst_end;
            mlib_f32 ss;

            dst = (void*)dstBase;
            dst_end = dst + width;

            while (((mlib_s32)dst & 7) && (dst < dst_end)) {
                pix = *src++;
                if (pix) STORE_INT;
                dst++;
            }

            off = (mlib_s32)src & 3;
            ss = *(mlib_f32*)(src - off);
            mask1 = vis_fcmpne16(vis_fpmerge(ss, fzero), dzero);

#pragma pipeloop(0)
            for (; dst <= (dst_end - 4); dst += 4) {
                mask0 = mask1;
                src += 4;
                ss = *(mlib_f32*)(src - off);
                mask1 = vis_fcmpne16(vis_fpmerge(ss, fzero), dzero);
                STORE_D64(16, dst, (mask0 << off) | (mask1 >> (4 - off)));
            }

            while (dst < dst_end) {
                pix = *src++;
                if (pix) STORE_INT;
                dst++;
            }

            PTR_ADD(dstBase, scan);
            pixels += rowBytes;
        }
    }
}

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

void ADD_SUFF(AnyIntDrawGlyphList)(GLYPH_LIST_PARAMS)
{
    mlib_s32 glyphCounter;
    mlib_s32 scan = pRasInfo->scanStride;
    mlib_u8  *dstBase;
    mlib_s32 j;
    mlib_d64 fgpixel_d;
    mlib_d64 dzero;
    mlib_s32 pix, mask0, mask1, mask, off;
    mlib_f32 fzero;

    INIT_FG

    fzero = vis_fzeros();
    dzero = vis_fzero();
    fgpixel_d = vis_to_double_dup(fgpixel);

    for (glyphCounter = 0; glyphCounter < totalGlyphs; glyphCounter++) {
        DEF_GLYPH(4);

        for (j = 0; j < height; j++) {
            mlib_u8 *src = (void*)pixels;
            mlib_u32 *dst, *dst_end;
            mlib_f32 ss;

            dst = (void*)dstBase;
            dst_end = dst + width;

            while (((mlib_s32)dst & 7) && (dst < dst_end)) {
                pix = *src++;
                if (pix) STORE_INT;
                dst++;
            }

            off = (mlib_s32)src & 3;
            ss = *(mlib_f32*)(src - off);
            mask1 = vis_fcmpne16(vis_fpmerge(ss, fzero), dzero);

#pragma pipeloop(0)
            for (; dst <= (dst_end - 4); dst += 4) {
                mask0 = mask1;
                src += 4;
                ss = *(mlib_f32*)(src - off);
                mask1 = vis_fcmpne16(vis_fpmerge(ss, fzero), dzero);
                mask = (mask0 << off) | (mask1 >> (4 - off));
                STORE_D64(32, dst, mask >> 2);
                STORE_D64(32, dst + 2, mask);
            }

            while (dst < dst_end) {
                pix = *src++;
                if (pix) STORE_INT;
                dst++;
            }

            PTR_ADD(dstBase, scan);
            pixels += rowBytes;
        }
    }
}

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

void ADD_SUFF(Any4ByteDrawGlyphList)(GLYPH_LIST_PARAMS)
{
    mlib_d64 buff[BUFF_SIZE/2];
    void     *pbuff = buff;
    mlib_s32 glyphCounter;
    mlib_s32 scan = pRasInfo->scanStride;
    mlib_u8  *dstBase;
    mlib_s32 j;
    mlib_d64 fgpixel_d;
    mlib_d64 dzero;
    mlib_s32 pix, mask0, mask1, mask, off;
    mlib_f32 fzero, fgpixel_f;
    mlib_s32 max_width = BUFF_SIZE;

    INIT_FG

    fzero = vis_fzeros();
    dzero = vis_fzero();
    fgpixel_f = vis_ldfa_ASI_PL(&fgpixel);
    fgpixel_d = vis_freg_pair(fgpixel_f, fgpixel_f);
    fgpixel = *(mlib_u32*)&fgpixel_f;

    for (glyphCounter = 0; glyphCounter < totalGlyphs; glyphCounter++) {
        DEF_GLYPH(4);

        if (((mlib_s32)dstBase | scan) & 3) {
            if (width > max_width) {
                if (pbuff != buff) {
                    mlib_free(pbuff);
                }
                pbuff = mlib_malloc(width*sizeof(mlib_s32));
                if (pbuff == NULL) return;
                max_width = width;
            }
        }

        for (j = 0; j < height; j++) {
            mlib_u8 *src = (void*)pixels;
            mlib_u32 *dst, *dst_end;
            mlib_f32 ss;

            if ((mlib_s32)dstBase & 3) {
                COPY_NA(dstBase, pbuff, width*sizeof(mlib_s32));
                dst = pbuff;
            } else {
                dst = (void*)dstBase;
            }
            dst_end = dst + width;

            while (((mlib_s32)dst & 7) && (dst < dst_end)) {
                pix = *src++;
                if (pix) STORE_INT;
                dst++;
            }

            off = (mlib_s32)src & 3;
            ss = *(mlib_f32*)(src - off);
            mask1 = vis_fcmpne16(vis_fpmerge(ss, fzero), dzero);

#pragma pipeloop(0)
            for (; dst <= (dst_end - 4); dst += 4) {
                mask0 = mask1;
                src += 4;
                ss = *(mlib_f32*)(src - off);
                mask1 = vis_fcmpne16(vis_fpmerge(ss, fzero), dzero);
                mask = (mask0 << off) | (mask1 >> (4 - off));
                STORE_D64(32, dst, mask >> 2);
                STORE_D64(32, dst + 2, mask);
            }

            while (dst < dst_end) {
                pix = *src++;
                if (pix) STORE_INT;
                dst++;
            }

            if ((mlib_s32)dstBase & 3) {
                COPY_NA(pbuff, dstBase, width*sizeof(mlib_s32));
            }

            PTR_ADD(dstBase, scan);
            pixels += rowBytes;
        }
    }

    if (pbuff != buff) {
        mlib_free(pbuff);
    }
}

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

#endif /* JAVA2D_NO_MLIB */