| /* |
| * Copyright (c) 1999, 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. |
| */ |
| |
| |
| |
| /* |
| * 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); |
| } |
| } |
| } |
| |
| /***************************************************************/ |
