diff -r fd16c54261b3 -r 90ce3da70b43 jdk/src/solaris/native/sun/awt/medialib/mlib_v_ImageCopy_f.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/jdk/src/solaris/native/sun/awt/medialib/mlib_v_ImageCopy_f.c Sat Dec 01 00:00:00 2007 +0000 @@ -0,0 +1,261 @@ +/* + * Copyright 1999-2003 Sun Microsystems, Inc. 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. Sun designates this + * particular file as subject to the "Classpath" exception as provided + * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ + + + +/* + * FUNCTIONS + * mlib_v_ImageCopy_a1 - 1-D, Aligned8, size 8x + * mlib_v_ImageCopy_a2 - 2-D, Aligned8, width 8x + * mlib_ImageCopy_na - BYTE, non-aligned + * mlib_ImageCopy_bit_al - BIT, aligned + * + * SYNOPSIS + * + * ARGUMENT + * sp pointer to source image data + * dp pointer to destination image data + * size size in 8-bytes, bytes, or SHORTs + * width image width in 8-bytes + * height image height in lines + * stride source image line stride in 8-bytes + * dstride destination image line stride in 8-bytes + * s_offset source image line bit offset + * d_offset destination image line bit offset + * + * DESCRIPTION + * Direct copy from one image to another -- VIS version low level + * functions. + * + * NOTE + * These functions are separated from mlib_v_ImageCopy.c for loop + * unrolling and structure clarity. + */ + +#include "vis_proto.h" +#include "mlib_image.h" +#include "mlib_ImageCopy.h" +#include "mlib_v_ImageCopy_f.h" + +#define VIS_ALIGNADDR(X, Y) vis_alignaddr((void *)(X), Y) + +/***************************************************************/ +/* + * Both source and destination image data are 1-d vectors and + * 8-byte aligned. And size is in 8-bytes. + */ + +void mlib_v_ImageCopy_a1(mlib_d64 *sp, + mlib_d64 *dp, + mlib_s32 size) +{ + mlib_s32 i; + +#pragma pipeloop(0) + for (i = 0; i < size; i++) { + *dp++ = *sp++; + } +} + +/***************************************************************/ +/* + * Either source or destination image data are not 1-d vectors, but + * they are 8-byte aligned. And stride and width are in 8-bytes. + */ + +void mlib_v_ImageCopy_a2(mlib_d64 *sp, + mlib_d64 *dp, + mlib_s32 width, + mlib_s32 height, + mlib_s32 stride, + mlib_s32 dstride) +{ + mlib_d64 *spl; /* 8-byte aligned pointer for line */ + mlib_d64 *dpl; /* 8-byte aligned pointer for line */ + mlib_s32 i, j; /* indices for x, y */ + + spl = sp; + dpl = dp; + + /* row loop */ + for (j = 0; j < height; j++) { + /* 8-byte column loop */ +#pragma pipeloop(0) + for (i = 0; i < width; i++) { + *dp++ = *sp++; + } + + sp = spl += stride; + dp = dpl += dstride; + } +} + +/***************************************************************/ +/* + * Both bit offsets of source and distination are the same + */ + +void mlib_ImageCopy_bit_al(const mlib_u8 *sa, + mlib_u8 *da, + mlib_s32 size, + mlib_s32 offset) +{ + mlib_u8 *dend; /* end points in dst */ + mlib_d64 *dp; /* 8-byte aligned start points in dst */ + mlib_d64 *sp; /* 8-byte aligned start point in src */ + mlib_d64 s0, s1; /* 8-byte source data */ + mlib_s32 j; /* offset of address in dst */ + mlib_s32 emask; /* edge mask */ + mlib_s32 b_size; /* size in bytes */ + mlib_u8 mask0 = 0xFF; + mlib_u8 src, mask; + + if (size <- 0) return; + + if (size < (8 - offset)) { + mask = mask0 << (8 - size); + mask >>= offset; + src = da[0]; + da[0] = (src & (~mask)) | (sa[0] & mask); + return; + } + + mask = mask0 >> offset; + src = da[0]; + da[0] = (src & (~mask)) | (sa[0] & mask); + da++; + sa++; + size = size - 8 + offset; + b_size = size >> 3; /* size in bytes */ + + /* prepare the destination addresses */ + dp = (mlib_d64 *) ((mlib_addr) da & (~7)); + j = (mlib_addr) dp - (mlib_addr) da; + dend = da + b_size - 1; + + /* prepare the source address */ + sp = (mlib_d64 *) VIS_ALIGNADDR(sa, j); + /* generate edge mask for the start point */ + emask = vis_edge8(da, dend); + + s1 = vis_ld_d64_nf(sp); + if (emask != 0xff) { + s0 = s1; + s1 = vis_ld_d64_nf(sp+1); + s0 = vis_faligndata(s0, s1); + vis_pst_8(s0, dp++, emask); + sp++; + j += 8; + } + +#pragma pipeloop(0) + for (; j <= (b_size - 8); j += 8) { + s0 = s1; + s1 = vis_ld_d64_nf(sp+1); + *dp++ = vis_faligndata(s0, s1); + sp++; + } + + if (j < b_size) { + s0 = vis_faligndata(s1, vis_ld_d64_nf(sp+1)); + emask = vis_edge8(dp, dend); + vis_pst_8(s0, dp, emask); + } + + j = size & 7; + + if (j > 0) { + mask = mask0 << (8 - j); + src = dend[1]; + dend[1] = (src & (~mask)) | (sa[b_size] & mask); + } +} + +/***************************************************************/ +/* + * Either source or destination data are not 8-byte aligned. + * And size is is in bytes. + */ + +void mlib_ImageCopy_na(const mlib_u8 *sa, + mlib_u8 *da, + mlib_s32 size) +{ + mlib_u8 *dend; /* end points in dst */ + mlib_d64 *dp; /* 8-byte aligned start points in dst */ + mlib_d64 *sp; /* 8-byte aligned start point in src */ + mlib_d64 s0, s1; /* 8-byte source data */ + mlib_s32 j; /* offset of address in dst */ + mlib_s32 emask; /* edge mask */ + + /* prepare the destination addresses */ + dp = (mlib_d64 *) ((mlib_addr) da & (~7)); + j = (mlib_addr) dp - (mlib_addr) da; + dend = da + size - 1; + + /* prepare the source address */ + sp = (mlib_d64 *) VIS_ALIGNADDR(sa, j); + /* generate edge mask for the start point */ + emask = vis_edge8(da, dend); + + s1 = vis_ld_d64_nf(sp); + if (emask != 0xff) { + s0 = s1; + s1 = vis_ld_d64_nf(sp+1); + s0 = vis_faligndata(s0, s1); + vis_pst_8(s0, dp++, emask); + sp++; + j += 8; + } + + if (((mlib_addr) sa ^ (mlib_addr) da) & 7) { +#pragma pipeloop(0) + for (; j <= (size - 8); j += 8) { + s0 = s1; + s1 = vis_ld_d64_nf(sp+1); + *dp++ = vis_faligndata(s0, s1); + sp++; + } + + if (j < size) { + s0 = vis_faligndata(s1, vis_ld_d64_nf(sp+1)); + emask = vis_edge8(dp, dend); + vis_pst_8(s0, dp, emask); + } + } + else { +#pragma pipeloop(0) + for (; j <= (size - 8); j += 8) { + *dp++ = *sp++; + } + + if (j < size) { + emask = vis_edge8(dp, dend); + vis_pst_8(vis_ld_d64_nf(sp), dp, emask); + } + } +} + +/***************************************************************/