/*
* Copyright (c) 2000, 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.
*/
/*
* FUNCTION
* mlib_ImageCopy - Direct copy from one image to another.
*
* SYNOPSIS
* mlib_status mlib_ImageCopy(mlib_image *dst,
* 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_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"
/***************************************************************/
extern void mlib_v_ImageCopy_blk(mlib_u8 *sa, mlib_u8 *da, mlib_s32 size);
extern void mlib_v_ImageCopy_a1(mlib_d64 *sp, mlib_d64 *dp, mlib_s32 size);
extern void mlib_ImageCopy_na(mlib_u8 *sa, mlib_u8 *da, mlib_s32 size);
extern void mlib_ImageCopy_bit_al(mlib_u8 *sa, mlib_u8 *da,
mlib_s32 size, mlib_s32 offset);
extern void mlib_ImageCopy_bit_na(mlib_u8 *sa, mlib_u8 *da, mlib_s32 size,
mlib_s32 s_offset, mlib_s32 d_offset);
/***************************************************************/
#ifdef MLIB_TEST
mlib_status mlib_v_ImageCopy(mlib_image *dst, mlib_image *src)
#else
mlib_status mlib_ImageCopy(mlib_image *dst, const mlib_image *src)
#endif
{
mlib_u8 *sa; /* start point in source */
mlib_u8 *da; /* start points in destination */
mlib_s32 width; /* width in bytes of src and dst */
mlib_s32 height; /* height in lines of src and dst */
mlib_s32 s_offset; /* bit offset of src */
mlib_s32 d_offset; /* bit offset of dst */
mlib_s32 stride; /* stride in bytes in src*/
mlib_s32 dstride; /* stride in bytes in dst */
mlib_s32 j; /* indices for x, y */
mlib_s32 size;
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);
width = mlib_ImageGetWidth(dst) * mlib_ImageGetChannels(dst);
height = mlib_ImageGetHeight(dst);
sa = (mlib_u8 *)mlib_ImageGetData(src);
da = (mlib_u8 *)mlib_ImageGetData(dst);
switch (mlib_ImageGetType(dst)) {
case MLIB_BIT:
if (!mlib_ImageIsNotOneDvector(src) &&
!mlib_ImageIsNotOneDvector(dst)) {
size = height * (width >> 3);
if ((size & 0x3f) == 0 &&
!mlib_ImageIsNotAligned64(src) &&
!mlib_ImageIsNotAligned64(dst)) {
mlib_v_ImageCopy_blk(sa, da, size);
return MLIB_SUCCESS;
}
if (((size & 7) == 0) && !mlib_ImageIsNotAligned8(src) &&
!mlib_ImageIsNotAligned8(dst)) {
size >>= 3; /* in octlet */
mlib_v_ImageCopy_a1((mlib_d64 *)sa, (mlib_d64 *)da, size);
}
else {
mlib_ImageCopy_na(sa, da, size);
}
}
else {
stride = mlib_ImageGetStride(src); /* in byte */
dstride = mlib_ImageGetStride(dst); /* in byte */
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 += stride;
da += dstride;
}
} else {
for (j = 0; j < height; j++) {
mlib_ImageCopy_bit_na(sa, da, width, s_offset, d_offset);
sa += stride;
da += dstride;
}
}
}
return MLIB_SUCCESS;
case MLIB_BYTE:
break;
case MLIB_SHORT:
width *= 2;
break;
case MLIB_INT:
case MLIB_FLOAT:
width *= 4;
break;
case MLIB_DOUBLE:
width *= 8;
break;
default:
return MLIB_FAILURE;
}
if (!mlib_ImageIsNotOneDvector(src) &&
!mlib_ImageIsNotOneDvector(dst)) {
size = height * width;
if ((size & 0x3f) == 0 &&
!mlib_ImageIsNotAligned64(src) &&
!mlib_ImageIsNotAligned64(dst)) {
mlib_v_ImageCopy_blk(sa, da, size);
return MLIB_SUCCESS;
}
if (((size & 7) == 0) && !mlib_ImageIsNotAligned8(src) &&
!mlib_ImageIsNotAligned8(dst)) {
size >>= 3; /* in octlet */
mlib_v_ImageCopy_a1((mlib_d64 *)sa, (mlib_d64 *)da, size);
}
else {
mlib_ImageCopy_na(sa, da, size);
}
}
else {
stride = mlib_ImageGetStride(src); /* in byte */
dstride = mlib_ImageGetStride(dst); /* in byte */
/* row loop */
for (j = 0; j < height; j++) {
mlib_ImageCopy_na(sa, da, width);
sa += stride;
da += dstride;
}
}
return MLIB_SUCCESS;
}
/***************************************************************/