/*
* Copyright (c) 1998, 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_ImageAffine_u8_1ch_nn
* mlib_ImageAffine_u8_2ch_nn
* mlib_ImageAffine_u8_3ch_nn
* mlib_ImageAffine_u8_4ch_nn
* mlib_ImageAffine_s16_1ch_nn
* mlib_ImageAffine_s16_2ch_nn
* mlib_ImageAffine_s16_3ch_nn
* mlib_ImageAffine_s16_4ch_nn
* - image affine transformation with Nearest Neighbor filtering
*
*/
#include "vis_proto.h"
#include "mlib_image.h"
#include "mlib_ImageCopy.h"
#include "mlib_ImageAffine.h"
#define BUFF_SIZE 256
/***************************************************************/
#define sp srcPixelPtr
#define dp dstPixelPtr
/***************************************************************/
#undef DTYPE
#define DTYPE mlib_u8
#define LD_U8(sp, x) vis_read_lo(vis_ld_u8_i(sp, ((x) >> MLIB_SHIFT)))
/***************************************************************/
mlib_status mlib_ImageAffine_u8_1ch_nn(mlib_affine_param *param)
{
DECLAREVAR();
mlib_s32 i, size;
#ifndef _NO_LONGLONG
mlib_s64 Y0, Y1, dYl;
#endif /* _NO_LONGLONG */
for (j = yStart; j <= yFinish; j++) {
mlib_d64 s0, s1;
CLIP(1);
size = xRight - xLeft + 1;
while (((mlib_s32)dp & 3) && (size > 0)) {
*dp = *(S_PTR(Y) + (X >> MLIB_SHIFT));
dp++;
X += dX;
Y += dY;
size--;
}
#ifdef _NO_LONGLONG
#pragma pipeloop(0)
for (i = 0; i <= (size - 4); i += 4) {
mlib_u8 *sp0, *sp1, *sp2, *sp3;
sp0 = S_PTR(Y);
sp1 = S_PTR(Y + dY);
sp2 = S_PTR(Y + 2*dY);
sp3 = S_PTR(Y + 3*dY);
s0 = vis_fpmerge(LD_U8(sp0, X), LD_U8(sp2, X + 2*dX));
s1 = vis_fpmerge(LD_U8(sp1, X + dX), LD_U8(sp3, X + 3*dX));
s0 = vis_fpmerge(vis_read_lo(s0), vis_read_lo(s1));
*(mlib_f32*)dp = vis_read_lo(s0);
dp += 4;
X += 4*dX;
Y += 4*dY;
}
#else
Y0 = ((mlib_s64)(Y + dY) << 32) | Y;
if (dY >= 0) {
dYl = ((mlib_s64)dY << 33) | (dY << 1);
} else {
dYl = -(((mlib_s64)(-dY) << 33) | ((-dY) << 1));
}
#pragma pipeloop(0)
for (i = 0; i <= (size - 4); i += 4) {
mlib_u8 *sp0, *sp1, *sp2, *sp3;
Y1 = Y0 + dYl;
sp0 = S_PTRl(Y0, 16);
sp1 = S_PTRl(Y0, 48);
sp2 = S_PTRl(Y1, 16);
sp3 = S_PTRl(Y1, 48);
s0 = vis_fpmerge(LD_U8(sp0, X), LD_U8(sp2, X + 2*dX));
s1 = vis_fpmerge(LD_U8(sp1, X + dX), LD_U8(sp3, X + 3*dX));
s0 = vis_fpmerge(vis_read_lo(s0), vis_read_lo(s1));
*(mlib_f32*)dp = vis_read_lo(s0);
dp += 4;
X += 4*dX;
Y0 += 2*dYl;
}
Y = Y0 & ((1u << 31) - 1);
#endif /* _NO_LONGLONG */
for (i = 0; i < (size & 3); i++) {
dp[i] = *(S_PTR(Y) + (X >> MLIB_SHIFT));
X += dX;
Y += dY;
}
}
return MLIB_SUCCESS;
}
/***************************************************************/
#undef LD_U8
#define LD_U8(sp, x) vis_read_lo(vis_ld_u8_i(sp, x))
/***************************************************************/
#define GET_POINTERS_2CH \
sp0 = S_PTR(Y) + 2*(X >> MLIB_SHIFT); \
sp1 = S_PTR(Y + dY) + 2*((X + dX) >> MLIB_SHIFT); \
sp2 = S_PTR(Y + 2*dY) + 2*((X + 2*dX) >> MLIB_SHIFT); \
sp3 = S_PTR(Y + 3*dY) + 2*((X + 3*dX) >> MLIB_SHIFT); \
X += 4*dX; \
Y += 4*dY
/***************************************************************/
#define AFFINE_U8_2CH \
s0 = vis_fpmerge(LD_U8(sp0, 0), LD_U8(sp2, 0)); \
s1 = vis_fpmerge(LD_U8(sp0, 1), LD_U8(sp2, 1)); \
s2 = vis_fpmerge(LD_U8(sp1, 0), LD_U8(sp3, 0)); \
s3 = vis_fpmerge(LD_U8(sp1, 1), LD_U8(sp3, 1)); \
\
s0 = vis_fpmerge(vis_read_lo(s0), vis_read_lo(s2)); \
s1 = vis_fpmerge(vis_read_lo(s1), vis_read_lo(s3)); \
dd = vis_fpmerge(vis_read_lo(s0), vis_read_lo(s1))
/***************************************************************/
mlib_status mlib_ImageAffine_u8_2ch_nn(mlib_affine_param *param)
{
DECLAREVAR();
DTYPE *dstLineEnd;
mlib_s32 i, size;
for (j = yStart; j <= yFinish; j++) {
mlib_u8 *sp0, *sp1, *sp2, *sp3;
mlib_d64 *da, s0, s1, s2, s3, dd, d_old;
mlib_s32 emask;
CLIP(2);
dstLineEnd = (DTYPE*)dstData + 2 * xRight;
size = xRight - xLeft + 1;
dstLineEnd++;
if (((mlib_s32)dp & 7) == 0) {
#pragma pipeloop(0)
for (i = 0; i <= (size - 4); i += 4) {
GET_POINTERS_2CH;
AFFINE_U8_2CH;
*(mlib_d64*)dp = dd;
dp += 8;
}
if (i < size) {
sp0 = sp1 = sp2 = sp3 = S_PTR(Y) + 2*(X >> MLIB_SHIFT);
if (i + 1 < size) sp1 = S_PTR(Y + dY) + 2*((X + dX) >> MLIB_SHIFT);
if (i + 2 < size) sp2 = S_PTR(Y + 2*dY) + 2*((X + 2*dX) >> MLIB_SHIFT);
if (i + 3 < size) sp3 = S_PTR(Y + 3*dY) + 2*((X + 3*dX) >> MLIB_SHIFT);
AFFINE_U8_2CH;
emask = vis_edge8(dp, dstLineEnd);
vis_pst_8(dd, dp, emask);
}
} else {
da = vis_alignaddr(dp, 0);
d_old = vis_faligndata(da[0], da[0]);
vis_alignaddr((void*)0, (mlib_u8*)da - dp);
#pragma pipeloop(0)
for (i = 0; i <= (size - 4); i += 4) {
GET_POINTERS_2CH;
AFFINE_U8_2CH;
*da++ = vis_faligndata(d_old, dd);
d_old = dd;
}
if (i < size) {
sp0 = sp1 = sp2 = sp3 = S_PTR(Y) + 2*(X >> MLIB_SHIFT);
if (i + 1 < size) sp1 = S_PTR(Y + dY) + 2*((X + dX) >> MLIB_SHIFT);
if (i + 2 < size) sp2 = S_PTR(Y + 2*dY) + 2*((X + 2*dX) >> MLIB_SHIFT);
if (i + 3 < size) sp3 = S_PTR(Y + 3*dY) + 2*((X + 3*dX) >> MLIB_SHIFT);
AFFINE_U8_2CH;
}
emask = vis_edge8(da, dstLineEnd);
vis_pst_8(vis_faligndata(d_old, dd), da++, emask);
if ((mlib_u8*)da <= dstLineEnd) {
emask = vis_edge8(da, dstLineEnd);
vis_pst_8(vis_faligndata(dd, dd), da, emask);
}
}
}
return MLIB_SUCCESS;
}
/***************************************************************/
#undef LD_U8
#define LD_U8(sp, x) vis_read_lo(vis_ld_u8(sp + x))
/***************************************************************/
mlib_status mlib_ImageAffine_u8_3ch_nn(mlib_affine_param *param)
{
DECLAREVAR();
DTYPE *srcPixelPtr;
mlib_s32 i, size;
for (j = yStart; j <= yFinish; j++) {
mlib_d64 s0, s1, s2, s3, s4, s5;
CLIP(3);
size = xRight - xLeft + 1;
while (((mlib_s32)dp & 3) && (size > 0)) {
sp = S_PTR(Y) + 3*(X >> MLIB_SHIFT);
dp[0] = sp[0];
dp[1] = sp[1];
dp[2] = sp[2];
dp += 3;
X += dX;
Y += dY;
size--;
}
#pragma pipeloop(0)
for (i = 0; i <= (size - 4); i += 4) {
mlib_u8 *sp0, *sp1, *sp2, *sp3;
sp0 = S_PTR(Y);
sp1 = S_PTR(Y + dY);
sp2 = S_PTR(Y + 2*dY);
sp3 = S_PTR(Y + 3*dY);
sp0 += 3*(X >> MLIB_SHIFT);
sp1 += 3*((X + dX) >> MLIB_SHIFT);
sp2 += 3*((X + 2*dX) >> MLIB_SHIFT);
sp3 += 3*((X + 3*dX) >> MLIB_SHIFT);
s0 = vis_fpmerge(LD_U8(sp0, 0), LD_U8(sp0, 2));
s1 = vis_fpmerge(LD_U8(sp0, 1), LD_U8(sp1, 0));
s0 = vis_fpmerge(vis_read_lo(s0), vis_read_lo(s1));
s2 = vis_fpmerge(LD_U8(sp1, 1), LD_U8(sp2, 0));
s3 = vis_fpmerge(LD_U8(sp1, 2), LD_U8(sp2, 1));
s2 = vis_fpmerge(vis_read_lo(s2), vis_read_lo(s3));
s4 = vis_fpmerge(LD_U8(sp2, 2), LD_U8(sp3, 1));
s5 = vis_fpmerge(LD_U8(sp3, 0), LD_U8(sp3, 2));
s4 = vis_fpmerge(vis_read_lo(s4), vis_read_lo(s5));
((mlib_f32*)dp)[0] = vis_read_lo(s0);
((mlib_f32*)dp)[1] = vis_read_lo(s2);
((mlib_f32*)dp)[2] = vis_read_lo(s4);
dp += 12;
X += 4*dX;
Y += 4*dY;
}
for (i = 0; i < (size & 3); i++) {
sp = S_PTR(Y) + 3*(X >> MLIB_SHIFT);
dp[0] = sp[0];
dp[1] = sp[1];
dp[2] = sp[2];
dp += 3;
X += dX;
Y += dY;
}
}
return MLIB_SUCCESS;
}
/***************************************************************/
#undef LD_U8
#define LD_U8(sp, x) vis_read_lo(vis_ld_u8_i(sp, x))
/***************************************************************/
#define AFFINE_U8_4x2 \
sp0 = S_PTR(Y) + 4*(X >> MLIB_SHIFT); \
sp1 = S_PTR(Y + dY) + 4*((X + dX) >> MLIB_SHIFT); \
\
s0 = vis_fpmerge(LD_U8(sp0, 0), LD_U8(sp1, 0)); \
s1 = vis_fpmerge(LD_U8(sp0, 1), LD_U8(sp1, 1)); \
s2 = vis_fpmerge(LD_U8(sp0, 2), LD_U8(sp1, 2)); \
s3 = vis_fpmerge(LD_U8(sp0, 3), LD_U8(sp1, 3)); \
\
s0 = vis_fpmerge(vis_read_lo(s0), vis_read_lo(s2)); \
s1 = vis_fpmerge(vis_read_lo(s1), vis_read_lo(s3)); \
dd = vis_fpmerge(vis_read_lo(s0), vis_read_lo(s1)); \
\
X += 2*dX; \
Y += 2*dY
/***************************************************************/
#define AFFINE_U8_4x1 \
sp0 = S_PTR(Y) + 4*(X >> MLIB_SHIFT); \
\
s0 = vis_fpmerge(LD_U8(sp0, 0), LD_U8(sp0, 2)); \
s1 = vis_fpmerge(LD_U8(sp0, 1), LD_U8(sp0, 3)); \
s0 = vis_fpmerge(vis_read_lo(s0), vis_read_lo(s1)); \
dd = vis_freg_pair(vis_read_lo(s0), vis_fzeros())
/***************************************************************/
mlib_status mlib_ImageAffine_u8_4ch_nn(mlib_affine_param *param)
{
DECLAREVAR();
DTYPE *dstLineEnd;
mlib_s32 i, size;
for (j = yStart; j <= yFinish; j++) {
mlib_u8 *sp0, *sp1;
mlib_d64 *da, s0, s1, s2, s3, dd, d_old;
mlib_s32 emask;
CLIP(4);
dstLineEnd = (DTYPE*)dstData + 4 * xRight;
size = xRight - xLeft + 1;
if (((mlib_s32)dp & 7) == 0) {
#pragma pipeloop(0)
for (i = 0; i <= (size - 2); i += 2) {
AFFINE_U8_4x2;
*(mlib_d64*)dp = dd;
dp += 8;
}
if (i < size) {
AFFINE_U8_4x1;
*(mlib_f32*)dp = vis_read_hi(dd);
}
} else {
da = vis_alignaddr(dp, 0);
d_old = vis_faligndata(da[0], da[0]);
vis_alignaddr((void*)0, (mlib_u8*)da - dp);
#pragma pipeloop(0)
for (i = 0; i <= (size - 2); i += 2) {
AFFINE_U8_4x2;
*da++ = vis_faligndata(d_old, dd);
d_old = dd;
}
if (i < size) {
AFFINE_U8_4x1;
}
dstLineEnd += 3;
emask = vis_edge8(da, dstLineEnd);
vis_pst_8(vis_faligndata(d_old, dd), da++, emask);
if ((mlib_u8*)da <= dstLineEnd) {
emask = vis_edge8(da, dstLineEnd);
vis_pst_8(vis_faligndata(dd, dd), da, emask);
}
}
}
return MLIB_SUCCESS;
}
/***************************************************************/
#undef DTYPE
#define DTYPE mlib_u16
#define SHIFT1(x) (((x) >> (MLIB_SHIFT - 1)) &~ 1)
/***************************************************************/
mlib_status mlib_ImageAffine_s16_1ch_nn(mlib_affine_param *param)
{
DECLAREVAR();
mlib_s32 i, size;
vis_alignaddr((void*)0, 6);
for (j = yStart; j <= yFinish; j++) {
mlib_d64 ss;
CLIP(1);
size = xRight - xLeft + 1;
while (((mlib_s32)dp & 7) && (size > 0)) {
*dp = *(S_PTR(Y) + (X >> MLIB_SHIFT));
dp++;
X += dX;
Y += dY;
size--;
}
#pragma pipeloop(0)
for (i = 0; i <= (size - 4); i += 4) {
mlib_u16 *sp0, *sp1, *sp2, *sp3;
sp0 = S_PTR(Y);
sp1 = S_PTR(Y + dY);
sp2 = S_PTR(Y + 2*dY);
sp3 = S_PTR(Y + 3*dY);
ss = vis_faligndata(vis_ld_u16_i(sp3, SHIFT1(X + 3*dX)), ss);
ss = vis_faligndata(vis_ld_u16_i(sp2, SHIFT1(X + 2*dX)), ss);
ss = vis_faligndata(vis_ld_u16_i(sp1, SHIFT1(X + dX)), ss);
ss = vis_faligndata(vis_ld_u16_i(sp0, SHIFT1(X)), ss);
*(mlib_d64*)dp = ss;
dp += 4;
X += 4*dX;
Y += 4*dY;
}
for (i = 0; i < (size & 3); i++) {
dp[i] = *(S_PTR(Y) + (X >> MLIB_SHIFT));
X += dX;
Y += dY;
}
}
return MLIB_SUCCESS;
}
/***************************************************************/
mlib_status mlib_ImageAffine_s16_2ch_nn(mlib_affine_param *param)
{
DECLAREVAR();
DTYPE *srcPixelPtr;
DTYPE *dstLineEnd;
for (j = yStart; j <= yFinish; j++) {
CLIP(2);
dstLineEnd = (DTYPE*)dstData + 2 * xRight;
#pragma pipeloop(0)
for (; dp <= dstLineEnd; dp += 2) {
sp = S_PTR(Y) + 2*(X >> MLIB_SHIFT);
dp[0] = sp[0];
dp[1] = sp[1];
X += dX;
Y += dY;
}
}
return MLIB_SUCCESS;
}
/***************************************************************/
#undef LD_U16
#define LD_U16(sp, x) vis_ld_u16(sp + x)
/***************************************************************/
mlib_status mlib_ImageAffine_s16_3ch_nn(mlib_affine_param *param)
{
DECLAREVAR();
DTYPE *srcPixelPtr;
mlib_s32 i, size;
vis_alignaddr((void*)0, 6);
for (j = yStart; j <= yFinish; j++) {
mlib_d64 s0, s1, s2;
CLIP(3);
size = xRight - xLeft + 1;
while (((mlib_s32)dp & 7) && (size > 0)) {
sp = S_PTR(Y) + 3*(X >> MLIB_SHIFT);
dp[0] = sp[0];
dp[1] = sp[1];
dp[2] = sp[2];
dp += 3;
X += dX;
Y += dY;
size--;
}
#pragma pipeloop(0)
for (i = 0; i <= (size - 4); i += 4) {
mlib_u16 *sp0, *sp1, *sp2, *sp3;
sp0 = S_PTR(Y);
sp1 = S_PTR(Y + dY);
sp2 = S_PTR(Y + 2*dY);
sp3 = S_PTR(Y + 3*dY);
sp0 += 3*(X >> MLIB_SHIFT);
sp1 += 3*((X + dX) >> MLIB_SHIFT);
sp2 += 3*((X + 2*dX) >> MLIB_SHIFT);
sp3 += 3*((X + 3*dX) >> MLIB_SHIFT);
s2 = vis_faligndata(LD_U16(sp3, 2), s2);
s2 = vis_faligndata(LD_U16(sp3, 1), s2);
s2 = vis_faligndata(LD_U16(sp3, 0), s2);
s2 = vis_faligndata(LD_U16(sp2, 2), s2);
s1 = vis_faligndata(LD_U16(sp2, 1), s1);
s1 = vis_faligndata(LD_U16(sp2, 0), s1);
s1 = vis_faligndata(LD_U16(sp1, 2), s1);
s1 = vis_faligndata(LD_U16(sp1, 1), s1);
s0 = vis_faligndata(LD_U16(sp1, 0), s0);
s0 = vis_faligndata(LD_U16(sp0, 2), s0);
s0 = vis_faligndata(LD_U16(sp0, 1), s0);
s0 = vis_faligndata(LD_U16(sp0, 0), s0);
((mlib_d64*)dp)[0] = s0;
((mlib_d64*)dp)[1] = s1;
((mlib_d64*)dp)[2] = s2;
dp += 12;
X += 4*dX;
Y += 4*dY;
}
for (i = 0; i < (size & 3); i++) {
sp = S_PTR(Y) + 3*(X >> MLIB_SHIFT);
dp[0] = sp[0];
dp[1] = sp[1];
dp[2] = sp[2];
dp += 3;
X += dX;
Y += dY;
}
}
return MLIB_SUCCESS;
}
/***************************************************************/
#define AFFINE_S16_4ch \
sp = S_PTR(Y) + 4*(X >> MLIB_SHIFT); \
\
dd = vis_faligndata(LD_U16(sp, 3), dd); \
dd = vis_faligndata(LD_U16(sp, 2), dd); \
dd = vis_faligndata(LD_U16(sp, 1), dd); \
dd = vis_faligndata(LD_U16(sp, 0), dd); \
\
X += dX; \
Y += dY
/***************************************************************/
mlib_status mlib_ImageAffine_s16_4ch_nn(mlib_affine_param *param)
{
DECLAREVAR();
DTYPE *srcPixelPtr;
mlib_s32 i, size, max_xsize = param -> max_xsize;
mlib_d64 buff[BUFF_SIZE], *pbuff = buff;
if (max_xsize > BUFF_SIZE) {
pbuff = mlib_malloc(sizeof(mlib_d64)*max_xsize);
}
for (j = yStart; j <= yFinish; j++) {
mlib_d64 *da, dd;
vis_alignaddr((void*)0, 6);
CLIP(4);
size = xRight - xLeft + 1;
if ((mlib_s32)dp & 7) {
da = buff;
} else {
da = (mlib_d64*)dp;
}
#pragma pipeloop(0)
for (i = 0; i < size; i++) {
AFFINE_S16_4ch;
da[i] = dd;
}
if ((mlib_s32)dp & 7) {
mlib_ImageCopy_na((mlib_u8*)buff, (mlib_u8*)dp, 8*size);
}
}
if (pbuff != buff) {
mlib_free(pbuff);
}
return MLIB_SUCCESS;
}
/***************************************************************/