| /* |
| * 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. |
| */ |
| |
| |
| /* |
| * FUNCTIONS |
| * mlib_ImageCopy - Direct copy from one image to another. |
| * |
| * SYNOPSIS |
| * mlib_status mlib_ImageCopy(mlib_image *dst, |
| * const mlib_image *src); |
| * |
| * ARGUMENT |
| * dst pointer to output or destination image |
| * src pointer to input or source image |
| * |
| * RESTRICTION |
| * src and dst must have the same size, type and number of channels. |
| * They can have 1, 2, 3 or 4 channels of MLIB_BIT, MLIB_BYTE, MLIB_SHORT, |
| * MLIB_USHORT, MLIB_INT, MLIB_FLOAT or MLIB_DOUBLE data type. |
| * |
| * DESCRIPTION |
| * Direct copy from one image to another |
| */ |
| |
| #include <stdlib.h> |
| #include "mlib_image.h" |
| #include "mlib_ImageCheck.h" |
| #include "mlib_ImageCopy.h" |
| |
| /***************************************************************/ |
| #ifdef _MSC_VER |
| #pragma optimize("", off) /* Fix bug 4195132 */ |
| #endif /* _MSC_VER */ |
| |
| /***************************************************************/ |
| /* do not perform the coping by mlib_d64 data type for x86 */ |
| #ifdef i386 |
| |
| typedef struct { |
| mlib_s32 int0, int1; |
| } two_int; |
| |
| #define TYPE_64BIT two_int |
| |
| #else /* i386 */ |
| |
| #define TYPE_64BIT mlib_d64 |
| #endif /* i386 */ |
| |
| /***************************************************************/ |
| static void mlib_c_ImageCopy_u8(const mlib_image *src, |
| mlib_image *dst); |
| static void mlib_c_ImageCopy_s16(const mlib_image *src, |
| mlib_image *dst); |
| static void mlib_c_ImageCopy_s32(const mlib_image *src, |
| mlib_image *dst); |
| static void mlib_c_ImageCopy_d64(const mlib_image *src, |
| mlib_image *dst); |
| static void mlib_c_ImageCopy_a1(const TYPE_64BIT *sp, |
| TYPE_64BIT *dp, |
| mlib_s32 size); |
| |
| /***************************************************************/ |
| mlib_status mlib_ImageCopy(mlib_image *dst, |
| const mlib_image *src) |
| { |
| mlib_s32 s_offset, d_offset; |
| mlib_s32 size, s_stride, d_stride; |
| mlib_s32 width; /* width in bytes of src and dst */ |
| mlib_s32 height; /* height in lines of src and dst */ |
| mlib_u8 *sa, *da; |
| mlib_s32 j; |
| |
| MLIB_IMAGE_CHECK(src); |
| MLIB_IMAGE_CHECK(dst); |
| MLIB_IMAGE_TYPE_EQUAL(src, dst); |
| MLIB_IMAGE_CHAN_EQUAL(src, dst); |
| MLIB_IMAGE_SIZE_EQUAL(src, dst); |
| |
| switch (mlib_ImageGetType(dst)) { |
| case MLIB_BIT: |
| width = mlib_ImageGetWidth(dst) * mlib_ImageGetChannels(dst); /* size in bits */ |
| height = mlib_ImageGetHeight(src); |
| sa = (mlib_u8 *) mlib_ImageGetData(src); |
| da = (mlib_u8 *) mlib_ImageGetData(dst); |
| |
| if (!mlib_ImageIsNotOneDvector(src) && !mlib_ImageIsNotOneDvector(dst)) { |
| size = height * (width >> 3); |
| if (!mlib_ImageIsNotAligned8(src) && !mlib_ImageIsNotAligned8(dst) && ((size & 7) == 0)) { |
| |
| mlib_c_ImageCopy_a1((TYPE_64BIT *) sa, (TYPE_64BIT *) da, size >> 3); |
| } |
| else { |
| |
| mlib_ImageCopy_na(sa, da, size); |
| } |
| } |
| else { |
| s_stride = mlib_ImageGetStride(src); |
| d_stride = mlib_ImageGetStride(dst); |
| s_offset = mlib_ImageGetBitOffset(src); /* in bits */ |
| d_offset = mlib_ImageGetBitOffset(dst); /* in bits */ |
| if (s_offset == d_offset) { |
| for (j = 0; j < height; j++) { |
| mlib_ImageCopy_bit_al(sa, da, width, s_offset); |
| sa += s_stride; |
| da += d_stride; |
| } |
| } |
| else { |
| for (j = 0; j < height; j++) { |
| mlib_ImageCopy_bit_na(sa, da, width, s_offset, d_offset); |
| sa += s_stride; |
| da += d_stride; |
| } |
| } |
| } |
| |
| break; |
| case MLIB_BYTE: |
| mlib_c_ImageCopy_u8(src, dst); |
| break; |
| case MLIB_SHORT: |
| case MLIB_USHORT: |
| mlib_c_ImageCopy_s16(src, dst); |
| break; |
| case MLIB_INT: |
| case MLIB_FLOAT: |
| mlib_c_ImageCopy_s32(src, dst); |
| break; |
| case MLIB_DOUBLE: |
| mlib_c_ImageCopy_d64(src, dst); |
| break; |
| default: |
| return MLIB_FAILURE; /* MLIB_BIT is not supported here */ |
| } |
| |
| return MLIB_SUCCESS; |
| } |
| |
| /***************************************************************/ |
| #define PREPAREVARS(type) \ |
| type *psrc = (type *) mlib_ImageGetData(src); \ |
| type *pdst = (type *) mlib_ImageGetData(dst); \ |
| mlib_s32 src_height = mlib_ImageGetHeight(src); \ |
| mlib_s32 src_width = mlib_ImageGetWidth(src); \ |
| mlib_s32 src_stride = mlib_ImageGetStride(src) / sizeof(type); \ |
| mlib_s32 dst_stride = mlib_ImageGetStride(dst) / sizeof(type); \ |
| mlib_s32 chan = mlib_ImageGetChannels(dst); \ |
| mlib_s32 i, j; \ |
| \ |
| src_width *= chan; \ |
| if (src_width == src_stride && src_width == dst_stride) { \ |
| src_width *= src_height; \ |
| src_height = 1; \ |
| } |
| |
| /***************************************************************/ |
| #define STRIP(pd, ps, w, h, data_type) { \ |
| data_type s0, s1; \ |
| for ( i = 0; i < h; i++ ) { \ |
| if (j = w & 1) \ |
| pd[i * dst_stride] = ps[i * src_stride]; \ |
| for (; j < w; j += 2) { \ |
| s0 = ps[i * src_stride + j]; \ |
| s1 = ps[i * src_stride + j + 1]; \ |
| pd[i * dst_stride + j] = s0; \ |
| pd[i * dst_stride + j + 1] = s1; \ |
| } \ |
| } \ |
| } |
| |
| /***************************************************************/ |
| /* |
| * 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_s32 b_size, i, j; |
| TYPE_64BIT *sp, *dp; |
| 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 */ |
| |
| for (j = 0; (j < b_size) && (((mlib_addr) da & 7) != 0); j++) |
| *da++ = *sa++; |
| |
| if ((((mlib_addr) sa ^ (mlib_addr) da) & 7) == 0) { |
| sp = (TYPE_64BIT *) sa; |
| dp = (TYPE_64BIT *) da; |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (i = 0; j <= (b_size - 8); j += 8, i++) { |
| dp[i] = sp[i]; |
| } |
| |
| sa += i << 3; |
| da += i << 3; |
| } |
| else { |
| #ifdef _NO_LONGLONG |
| if ((((mlib_addr) sa ^ (mlib_addr) da) & 3) == 0) { |
| mlib_u32 *pws, *pwd; |
| |
| pws = (mlib_u32 *) sa; |
| pwd = (mlib_u32 *) da; |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (i = 0; j <= (b_size - 4); j += 4, i++) { |
| pwd[i] = pws[i]; |
| } |
| |
| sa += i << 2; |
| da += i << 2; |
| } |
| else { |
| mlib_u32 *pws, *pwd, src0, src1; |
| mlib_s32 lshift = (mlib_addr) sa & 3, rshift; |
| |
| pwd = (mlib_u32 *) da; |
| pws = (mlib_u32 *) (sa - lshift); |
| lshift <<= 3; |
| rshift = 32 - lshift; |
| |
| src1 = pws[0]; |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (i = 0; j <= (b_size - 4); j += 4, i++) { |
| src0 = src1; |
| src1 = pws[i + 1]; |
| #ifdef _LITTLE_ENDIAN |
| pwd[i] = (src0 >> lshift) | (src1 << rshift); |
| #else |
| pwd[i] = (src0 << lshift) | (src1 >> rshift); |
| #endif /* _LITTLE_ENDIAN */ |
| } |
| |
| sa += i << 2; |
| da += i << 2; |
| } |
| |
| #else |
| mlib_u64 *pws, *pwd, src0, src1; |
| mlib_s32 lshift = (mlib_s32) ((mlib_addr) sa & 7), rshift; |
| |
| pwd = (mlib_u64 *) da; |
| pws = (mlib_u64 *) (sa - lshift); |
| lshift <<= 3; |
| rshift = 64 - lshift; |
| |
| src1 = pws[0]; |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (i = 0; j <= (b_size - 8); j += 8, i++) { |
| src0 = src1; |
| src1 = pws[i + 1]; |
| pwd[i] = (src0 << lshift) | (src1 >> rshift); |
| } |
| |
| sa += i << 3; |
| da += i << 3; |
| #endif /* _NO_LONGLONG */ |
| } |
| |
| for (; j < b_size; j++) |
| *da++ = *sa++; |
| |
| j = size & 7; |
| |
| if (j > 0) { |
| mask = mask0 << (8 - j); |
| src = da[0]; |
| da[0] = (src & (~mask)) | (sa[0] & mask); |
| } |
| } |
| |
| /***************************************************************/ |
| void mlib_c_ImageCopy_u8(const mlib_image *src, |
| mlib_image *dst) |
| { |
| PREPAREVARS(mlib_u8); |
| if (src_width < 16) { |
| STRIP(pdst, psrc, src_width, src_height, mlib_u8); |
| return; |
| } |
| |
| for (i = 0; i < src_height; i++) { |
| mlib_u8 *psrc_row = psrc + i * src_stride, *pdst_row = pdst + i * dst_stride; |
| |
| if (!(((mlib_addr) psrc_row ^ (mlib_addr) pdst_row) & 7)) { |
| for (j = 0; j < (mlib_s32) ((8 - (mlib_addr) psrc_row) & 7); j++) { |
| pdst_row[j] = psrc_row[j]; |
| } |
| |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (; j <= (src_width - 8); j += 8) { |
| TYPE_64BIT dsrc0 = *((TYPE_64BIT *) (psrc_row + j)); |
| |
| *((TYPE_64BIT *) (pdst_row + j)) = dsrc0; |
| } |
| } |
| else { |
| |
| #ifdef _NO_LONGLONG |
| |
| for (j = 0; j < (mlib_s32) ((4 - (mlib_addr) pdst_row) & 3); j++) { |
| pdst_row[j] = psrc_row[j]; |
| } |
| |
| if (!(((mlib_addr) psrc_row ^ (mlib_addr) pdst_row) & 3)) { |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (; j <= (src_width - 4); j += 4) { |
| *((mlib_s32 *) (pdst_row + j)) = *((mlib_s32 *) (psrc_row + j)); |
| } |
| } |
| else { |
| mlib_u32 *ps, shl, shr, src0, src1; |
| |
| ps = (mlib_u32 *) (psrc_row + j); |
| shl = (mlib_addr) ps & 3; |
| ps = (mlib_u32 *) ((mlib_addr) ps - shl); |
| shl <<= 3; |
| shr = 32 - shl; |
| |
| src1 = ps[0]; |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (; j <= (src_width - 4); j += 4) { |
| src0 = src1; |
| src1 = ps[1]; |
| #ifdef _LITTLE_ENDIAN |
| *((mlib_s32 *) (pdst_row + j)) = (src0 >> shl) | (src1 << shr); |
| #else |
| *((mlib_s32 *) (pdst_row + j)) = (src0 << shl) | (src1 >> shr); |
| #endif /* _LITTLE_ENDIAN */ |
| ps++; |
| } |
| } |
| |
| #else |
| |
| for (j = 0; j < (mlib_s32) ((8 - (mlib_addr) pdst_row) & 7); j++) { |
| pdst_row[j] = psrc_row[j]; |
| } |
| |
| { |
| mlib_s32 shl, shr; |
| mlib_u64 *ps, src0, src1; |
| |
| ps = (mlib_u64 *) (psrc_row + j); |
| /* shl and shr are in range [0, 64] */ |
| shl = (mlib_s32) ((mlib_addr) ps & 7); |
| ps = (mlib_u64 *) ((mlib_addr) ps - shl); |
| shl <<= 3; |
| shr = 64 - shl; |
| |
| src1 = ps[0]; |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (; j <= (src_width - 8); j += 8) { |
| src0 = src1; |
| src1 = ps[1]; |
| #ifdef _LITTLE_ENDIAN |
| *((mlib_s64 *) (pdst_row + j)) = (src0 >> shl) | (src1 << shr); |
| #else |
| *((mlib_s64 *) (pdst_row + j)) = (src0 << shl) | (src1 >> shr); |
| #endif /* _LITTLE_ENDIAN */ |
| ps++; |
| } |
| } |
| #endif /* _NO_LONGLONG */ |
| } |
| |
| for (; j < src_width; j++) |
| pdst_row[j] = psrc_row[j]; |
| } |
| } |
| |
| /***************************************************************/ |
| void mlib_c_ImageCopy_s16(const mlib_image *src, |
| mlib_image *dst) |
| { |
| PREPAREVARS(mlib_u16); |
| if (src_width < 8) { |
| STRIP(pdst, psrc, src_width, src_height, mlib_u16); |
| return; |
| } |
| |
| for (i = 0; i < src_height; i++) { |
| mlib_u16 *psrc_row = psrc + i * src_stride, *pdst_row = pdst + i * dst_stride; |
| |
| if (!(((mlib_addr) psrc_row ^ (mlib_addr) pdst_row) & 7)) { |
| for (j = 0; j < (mlib_s32) (((8 - (mlib_addr) psrc_row) & 7) >> 1); j++) { |
| pdst_row[j] = psrc_row[j]; |
| } |
| |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (; j <= (src_width - 4); j += 4) { |
| TYPE_64BIT dsrc0 = *((TYPE_64BIT *) (psrc_row + j)); |
| |
| *((TYPE_64BIT *) (pdst_row + j)) = dsrc0; |
| } |
| } |
| else { |
| |
| #ifdef _NO_LONGLONG |
| |
| if (j = (((mlib_addr) pdst_row & 2) != 0)) { |
| pdst_row[0] = psrc_row[0]; |
| } |
| |
| if (!(((mlib_addr) psrc_row ^ (mlib_addr) pdst_row) & 3)) { |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (; j <= (src_width - 2); j += 2) { |
| *((mlib_s32 *) (pdst_row + j)) = *((mlib_s32 *) (psrc_row + j)); |
| } |
| } |
| else { |
| mlib_u32 *ps, src0, src1; |
| |
| ps = (mlib_u32 *) (psrc_row + j - 1); |
| src1 = ps[0]; |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (; j <= (src_width - 2); j += 2) { |
| src0 = src1; |
| src1 = ps[1]; |
| #ifdef _LITTLE_ENDIAN |
| *((mlib_s32 *) (pdst_row + j)) = (src0 >> 16) | (src1 << 16); |
| #else |
| *((mlib_s32 *) (pdst_row + j)) = (src0 << 16) | (src1 >> 16); |
| #endif /* _LITTLE_ENDIAN */ |
| ps++; |
| } |
| } |
| |
| #else |
| |
| for (j = 0; j < (mlib_s32) (((8 - (mlib_addr) pdst_row) & 7) >> 1); j++) { |
| pdst_row[j] = psrc_row[j]; |
| } |
| |
| { |
| mlib_s32 shl, shr; |
| mlib_u64 *ps, src0, src1; |
| |
| ps = (mlib_u64 *) (psrc_row + j); |
| shl = (mlib_s32) ((mlib_addr) ps & 7); |
| ps = (mlib_u64 *) ((mlib_addr) ps - shl); |
| shl <<= 3; |
| shr = 64 - shl; |
| |
| src1 = ps[0]; |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (; j <= (src_width - 4); j += 4) { |
| src0 = src1; |
| src1 = ps[1]; |
| #ifdef _LITTLE_ENDIAN |
| *((mlib_s64 *) (pdst_row + j)) = (src0 >> shl) | (src1 << shr); |
| #else |
| *((mlib_s64 *) (pdst_row + j)) = (src0 << shl) | (src1 >> shr); |
| #endif /* _LITTLE_ENDIAN */ |
| ps++; |
| } |
| } |
| #endif /* _NO_LONGLONG */ |
| } |
| |
| for (; j < src_width; j++) |
| pdst_row[j] = psrc_row[j]; |
| } |
| } |
| |
| /***************************************************************/ |
| void mlib_c_ImageCopy_s32(const mlib_image *src, |
| mlib_image *dst) |
| { |
| PREPAREVARS(mlib_u32); |
| if (src_width < 4) { |
| STRIP(pdst, psrc, src_width, src_height, mlib_u32); |
| return; |
| } |
| |
| for (i = 0; i < src_height; i++) { |
| mlib_u32 *psrc_row = psrc + i * src_stride, *pdst_row = pdst + i * dst_stride; |
| |
| if (!(((mlib_addr) psrc_row ^ (mlib_addr) pdst_row) & 7)) { |
| if (j = ((mlib_s32) ((mlib_addr) psrc_row & 4) >> 2)) { |
| pdst_row[0] = psrc_row[0]; |
| } |
| |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (; j <= (src_width - 2); j += 2) { |
| TYPE_64BIT dsrc0 = *((TYPE_64BIT *) (psrc_row + j)); |
| |
| *((TYPE_64BIT *) (pdst_row + j)) = dsrc0; |
| } |
| } |
| else { |
| |
| #ifdef _NO_LONGLONG |
| |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (j = 0; j <= (src_width - 1); j++) { |
| *((mlib_s32 *) (pdst_row + j)) = *((mlib_s32 *) (psrc_row + j)); |
| } |
| |
| #else |
| |
| { |
| mlib_u64 *ps, src0, src1; |
| |
| if (j = ((mlib_s32) ((mlib_addr) pdst_row & 4) >> 2)) |
| pdst_row[0] = psrc_row[0]; |
| ps = (mlib_u64 *) (psrc_row + j - 1); |
| src1 = ps[0]; |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (; j <= (src_width - 2); j += 2) { |
| src0 = src1; |
| src1 = ps[1]; |
| #ifdef _LITTLE_ENDIAN |
| *((mlib_s64 *) (pdst_row + j)) = (src0 >> 32) | (src1 << 32); |
| #else |
| *((mlib_s64 *) (pdst_row + j)) = (src0 << 32) | (src1 >> 32); |
| #endif /* _LITTLE_ENDIAN */ |
| ps++; |
| } |
| } |
| #endif /* _NO_LONGLONG */ |
| } |
| |
| for (; j < src_width; j++) |
| pdst_row[j] = psrc_row[j]; |
| } |
| } |
| |
| /***************************************************************/ |
| void mlib_c_ImageCopy_d64(const mlib_image *src, |
| mlib_image *dst) |
| { |
| PREPAREVARS(mlib_d64); |
| for (i = 0; i < src_height; i++) { |
| mlib_d64 *psrc_row = psrc + i * src_stride, *pdst_row = pdst + i * dst_stride; |
| |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (j = 0; j < src_width; j++) |
| *((mlib_d64 *) (pdst_row + j)) = *((mlib_d64 *) (psrc_row + j)); |
| } |
| } |
| |
| /***************************************************************/ |
| /* |
| * Both source and destination image data are 1 - d vectors and |
| * 8 - byte aligned. And size is in 8 - bytes. |
| */ |
| |
| void mlib_c_ImageCopy_a1(const TYPE_64BIT *sp, |
| TYPE_64BIT *dp, |
| mlib_s32 size) |
| { |
| mlib_s32 i; |
| |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (i = 0; i < size; i++) { |
| *dp++ = *sp++; |
| } |
| } |
| |
| /***************************************************************/ |
| #ifndef _NO_LONGLONG |
| #define TYPE mlib_u64 |
| #define BSIZE 64 |
| #define SIZE 8 |
| #else |
| #define TYPE mlib_u32 |
| #define BSIZE 32 |
| #define SIZE 4 |
| #endif /* _NO_LONGLONG */ |
| |
| /***************************************************************/ |
| void mlib_ImageCopy_na(const mlib_u8 *sp, |
| mlib_u8 *dp, |
| mlib_s32 n) |
| { |
| mlib_s32 shr, shl; |
| TYPE *tmp, s0, s1; |
| |
| if (((mlib_addr) sp ^ (mlib_addr) dp) & 7) { |
| |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (; (n > 0) && (mlib_addr) dp & (SIZE - 1); n--) |
| *dp++ = *sp++; |
| |
| #ifdef _NO_LONGLONG |
| |
| if (((mlib_addr) sp & (SIZE - 1)) == 0) { |
| for (; n > SIZE; n -= SIZE) { |
| *(TYPE *) dp = *(TYPE *) sp; |
| dp += SIZE; |
| sp += SIZE; |
| } |
| } |
| else |
| #endif /* _NO_LONGLONG */ |
| { |
| tmp = (TYPE *) ((mlib_addr) sp & ~(SIZE - 1)); |
| /* shl and shr do not exceed 64 here */ |
| shl = (mlib_s32) (((mlib_addr) sp & (SIZE - 1)) << 3); |
| shr = BSIZE - shl; |
| s0 = *tmp++; |
| |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (; n > SIZE; n -= SIZE) { |
| s1 = *tmp++; |
| #ifdef _LITTLE_ENDIAN |
| *(TYPE *) dp = (s0 >> shl) | (s1 << shr); |
| #else |
| *(TYPE *) dp = (s0 << shl) | (s1 >> shr); |
| #endif /* _LITTLE_ENDIAN */ |
| s0 = s1; |
| dp += SIZE; |
| sp += SIZE; |
| } |
| } |
| } |
| else { |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (; (n > 0) && (mlib_addr) dp & 7; n--) |
| *dp++ = *sp++; |
| |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (; n > 8; n -= 8) { |
| *(TYPE_64BIT *) dp = *(TYPE_64BIT *) sp; |
| dp += 8; |
| sp += 8; |
| } |
| } |
| |
| #ifdef __SUNPRO_C |
| #pragma pipeloop(0) |
| #endif /* __SUNPRO_C */ |
| for (; n > 0; n--) |
| *dp++ = *sp++; |
| } |
| |
| /***************************************************************/ |
| #ifdef _MSC_VER |
| #pragma optimize("", on) |
| #endif /* _MSC_VER */ |
| |
| /***************************************************************/ |
