/*

 * 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.

 */

#include "mlib_image.h"

#include "mlib_ImageAffine.h"

#include "mlib_ImageColormap.h"

/***************************************************************/

#define MLIB_LIMIT  512

/***************************************************************/

#define DTYPE  MLIB_TYPE

/***************************************************************/

#define DECLAREVAR_IND()                                        \

  DECLAREVAR0();                                                \

  mlib_s32  *warp_tbl   = param -> warp_tbl;                    \

  mlib_s32  xSrc, ySrc;                                         \

  mlib_s32  srcYStride = param -> srcYStride;                   \

  mlib_s32  max_xsize  = param -> max_xsize;                    \

  MLIB_TYPE *sp0, *sp1;                                         \

  MLIB_TYPE *dl;                                                \

  mlib_d64  scale = 1.0 / 65536.0;                              \

  mlib_s32  i, size

/***************************************************************/

#define DECLARE_INTERNAL_VAR_3CH()                              \

  mlib_d64  fdx, fdy;                                           \

  mlib_d64  a00_0, a01_0, a10_0, a11_0;                         \

  mlib_d64  a00_1, a01_1, a10_1, a11_1;                         \

  mlib_d64  a00_2, a01_2, a10_2, a11_2;                         \

  mlib_d64  pix0_0, pix1_0, res0;                               \

  mlib_d64  pix0_1, pix1_1, res1;                               \

  mlib_d64  pix0_2, pix1_2, res2

/***************************************************************/

#define DECLARE_INTERNAL_VAR_4CH()                              \

  mlib_d64  fdx, fdy;                                           \

  mlib_d64  a00_0, a01_0, a10_0, a11_0;                         \

  mlib_d64  a00_1, a01_1, a10_1, a11_1;                         \

  mlib_d64  a00_2, a01_2, a10_2, a11_2;                         \

  mlib_d64  a00_3, a01_3, a10_3, a11_3;                         \

  mlib_d64  pix0_0, pix1_0, res0;                               \

  mlib_d64  pix0_1, pix1_1, res1;                               \

  mlib_d64  pix0_2, pix1_2, res2;                               \

  mlib_d64  pix0_3, pix1_3, res3

/***************************************************************/

#define GET_PIXELS_POINTERS()                                   \

  fdx = (X & MLIB_MASK) * scale;                                \

  fdy = (Y & MLIB_MASK) * scale;                                \

  ySrc = MLIB_POINTER_SHIFT(Y);  Y += dY;                       \

  xSrc = X >> MLIB_SHIFT;  X += dX;                             \

  sp0 = MLIB_POINTER_GET(lineAddr, ySrc) + xSrc;                \

  sp1 = (MLIB_TYPE *)((mlib_u8 *)sp0 + srcYStride)

/***************************************************************/

#define GET_COLOR_POINTERS(ind)                                 \

  pcolor00 = (lut + sp0[0]*ind);                                \

  pcolor10 = (lut + sp1[0]*ind);                                \

  pcolor01 = (lut + sp0[1]*ind);                                \

  pcolor11 = (lut + sp1[1]*ind)

/***************************************************************/

#define COUNT_BL_U8(ind)                                        \

  pix0_##ind = a00_##ind + fdy * (a10_##ind - a00_##ind);       \

  pix1_##ind = a01_##ind + fdy * (a11_##ind - a01_##ind);       \

  res##ind = pix0_##ind + fdx * (pix1_##ind - pix0_##ind) + 0.5

/***************************************************************/

#define COUNT_BL_U8_3CH()                                       \

  COUNT_BL_U8(0);                                               \

  COUNT_BL_U8(1);                                               \

  COUNT_BL_U8(2);

/***************************************************************/

#define COUNT_BL_U8_4CH()                                       \

  COUNT_BL_U8_3CH();                                            \

  COUNT_BL_U8(3);

/***************************************************************/

#define COUNT_BL_S16(ind)                                       \

  pix0_##ind = a00_##ind + fdy * (a10_##ind - a00_##ind);       \

  pix1_##ind = a01_##ind + fdy * (a11_##ind - a01_##ind);       \

  res##ind = pix0_##ind + fdx * (pix1_##ind - pix0_##ind)

/***************************************************************/

#define COUNT_BL_S16_3CH()                                      \

  COUNT_BL_S16(0);                                              \

  COUNT_BL_S16(1);                                              \

  COUNT_BL_S16(2);

/***************************************************************/

#define COUNT_BL_S16_4CH()                                      \

  COUNT_BL_S16_3CH();                                           \

  COUNT_BL_S16(3);

/***************************************************************/

#define LOAD(ind)                                               \

  a00_##ind = pcolor00[ind];                                    \

  a01_##ind = pcolor01[ind];                                    \

  a10_##ind = pcolor10[ind];                                    \

  a11_##ind = pcolor11[ind]

/***************************************************************/

#define LOAD_3CH()                                              \

  LOAD(0);                                                      \

  LOAD(1);                                                      \

  LOAD(2);

/***************************************************************/

#define LOAD_4CH()                                              \

  LOAD_3CH();                                                   \

  LOAD(3);

/***************************************************************/

#define STORE_INTO_INTERM_BUF_3CH(LTYPE)                        \

  dp[0] = (mlib_##LTYPE)res0;                                   \

  dp[1] = (mlib_##LTYPE)res1;                                   \

  dp[2] = (mlib_##LTYPE)res2

/***************************************************************/

#define STORE_INTO_INTERM_BUF_4CH(LTYPE)                        \

  dp[0] = (mlib_##LTYPE)res0;                                   \

  dp[1] = (mlib_##LTYPE)res1;                                   \

  dp[2] = (mlib_##LTYPE)res2;                                   \

  dp[3] = (mlib_##LTYPE)res3

/***************************************************************/

#undef  MLIB_TYPE

#define MLIB_TYPE mlib_u8

/***************************************************************/

#define mlib_U8  mlib_u8

#define mlib_S16 mlib_s16

/***************************************************************/

#define FUNC_AFFINEINDEX_BL_0(ITYPE, LTYPE, NCHAN)                                               \

  mlib_status mlib_ImageAffineIndex_##ITYPE##_##LTYPE##_##NCHAN##CH_BL(mlib_affine_param *param, \

                                                                       const void        *colormap) \

  {                                                                                              \

    DECLAREVAR_IND();                                                                            \

    mlib_##LTYPE  *dp, buff_lcl[NCHAN*MLIB_LIMIT], *pbuff = buff_lcl;                            \

    mlib_d64 *pcolor00, *pcolor10, *pcolor01, *pcolor11;                                         \

    mlib_d64 *lut = mlib_ImageGetLutDoubleData(colormap);                                        \

                                                                                                 \

    lut -= NCHAN*mlib_ImageGetLutOffset(colormap);                                               \

                                                                                                 \

    if (max_xsize > MLIB_LIMIT) {                                                                \

      pbuff = mlib_malloc(NCHAN * sizeof(mlib_##LTYPE) * max_xsize);                             \

      if (pbuff == NULL) return MLIB_FAILURE;                                                    \

    }                                                                                            \

                                                                                                 \

    for (j = yStart; j <= yFinish; j++) {                                                        \

      DECLARE_INTERNAL_VAR_##NCHAN##CH();                                                        \

                                                                                                 \

      NEW_LINE(1);                                                                               \

      dp = pbuff;                                                                                \

                                                                                                 \

      GET_PIXELS_POINTERS();                                                                     \

      GET_COLOR_POINTERS(NCHAN);                                                                 \

      LOAD_##NCHAN##CH();

    /* pragma pipeloop(0) must be here */

/***************************************************************/

#define FUNC_AFFINEINDEX_BL_1(ITYPE, LTYPE, NCHAN)                   \

      for (i = 0; i < (xRight - xLeft); i++, dp += NCHAN) {          \

        COUNT_BL_##LTYPE##_##NCHAN##CH();                            \

                                                                     \

        GET_PIXELS_POINTERS();                                       \

        GET_COLOR_POINTERS(NCHAN);                                   \

        LOAD_##NCHAN##CH();                                          \

                                                                     \

        STORE_INTO_INTERM_BUF_##NCHAN##CH(LTYPE);                    \

      }                                                              \

                                                                     \

      COUNT_BL_##LTYPE##_##NCHAN##CH();                              \

      STORE_INTO_INTERM_BUF_##NCHAN##CH(LTYPE);                      \

                                                                     \

      mlib_ImageColorTrue2IndexLine_##LTYPE##_##ITYPE##_##NCHAN      \

                          (pbuff, dl, xRight - xLeft + 1, colormap); \

    }                                                                \

                                                                     \

    if (pbuff != buff_lcl) mlib_free(pbuff);                         \

                                                                     \

    return MLIB_SUCCESS;                                             \

  }

/***************************************************************/

#undef  MLIB_TYPE

#define MLIB_TYPE mlib_u8

FUNC_AFFINEINDEX_BL_0(U8, U8, 3)

#ifdef __SUNPRO_C

#pragma pipeloop(0)

#endif /* __SUNPRO_C */

FUNC_AFFINEINDEX_BL_1(U8, U8, 3)

FUNC_AFFINEINDEX_BL_0(U8, S16, 3)

#ifdef __SUNPRO_C

#pragma pipeloop(0)

#endif /* __SUNPRO_C */

FUNC_AFFINEINDEX_BL_1(U8, S16, 3)

FUNC_AFFINEINDEX_BL_0(U8, U8, 4)

#ifdef __SUNPRO_C

#pragma pipeloop(0)

#endif /* __SUNPRO_C */

FUNC_AFFINEINDEX_BL_1(U8, U8, 4)

FUNC_AFFINEINDEX_BL_0(U8, S16, 4)

#ifdef __SUNPRO_C

#pragma pipeloop(0)

#endif /* __SUNPRO_C */

FUNC_AFFINEINDEX_BL_1(U8, S16, 4)

/***************************************************************/

#undef  MLIB_TYPE

#define MLIB_TYPE mlib_s16

FUNC_AFFINEINDEX_BL_0(S16, U8, 3)

#ifdef __SUNPRO_C

#pragma pipeloop(0)

#endif /* __SUNPRO_C */

FUNC_AFFINEINDEX_BL_1(S16, U8, 3)

FUNC_AFFINEINDEX_BL_0(S16, S16, 3)

#ifdef __SUNPRO_C

#pragma pipeloop(0)

#endif /* __SUNPRO_C */

FUNC_AFFINEINDEX_BL_1(S16, S16, 3)

FUNC_AFFINEINDEX_BL_0(S16, U8, 4)

#ifdef __SUNPRO_C

#pragma pipeloop(0)

#endif /* __SUNPRO_C */

FUNC_AFFINEINDEX_BL_1(S16, U8, 4)

FUNC_AFFINEINDEX_BL_0(S16, S16, 4)

#ifdef __SUNPRO_C

#pragma pipeloop(0)

#endif /* __SUNPRO_C */

FUNC_AFFINEINDEX_BL_1(S16, S16, 4)

/***************************************************************/

const type_affine_i_fun mlib_AffineFunArr_bl_i[] = {

  mlib_ImageAffineIndex_U8_U8_3CH_BL,

  mlib_ImageAffineIndex_U8_U8_4CH_BL,

  mlib_ImageAffineIndex_S16_U8_3CH_BL,

  mlib_ImageAffineIndex_S16_U8_4CH_BL,

  mlib_ImageAffineIndex_U8_S16_3CH_BL,

  mlib_ImageAffineIndex_U8_S16_4CH_BL,

  mlib_ImageAffineIndex_S16_S16_3CH_BL,

  mlib_ImageAffineIndex_S16_S16_4CH_BL

};

/***************************************************************/