/*

 * 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

 *   Internal functions for mlib_ImageConv* on S32 type and

 *   MLIB_EDGE_DST_NO_WRITE mask

 *

 */

#include "mlib_image.h"

#include "mlib_ImageConv.h"

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

#define BUFF_LINE  256

#define CACHE_SIZE (64*1024)

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

#define CONV_FUNC(KERN) mlib_conv##KERN##nw_s32

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

#ifndef MLIB_USE_FTOI_CLAMPING

#define CLAMP_S32(dst, src)                                       \

  if (src > (mlib_d64)MLIB_S32_MAX) src = (mlib_d64)MLIB_S32_MAX; \

  if (src < (mlib_d64)MLIB_S32_MIN) src = (mlib_d64)MLIB_S32_MIN; \

  dst = (mlib_s32)src

#else

#define CLAMP_S32(dst, src) dst = (mlib_s32)(src)

#endif /* MLIB_USE_FTOI_CLAMPING */

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

#define GET_SRC_DST_PARAMETERS(type)                            \

  mlib_s32 hgt = mlib_ImageGetHeight(src);                      \

  mlib_s32 wid = mlib_ImageGetWidth(src);                       \

  mlib_s32 sll = mlib_ImageGetStride(src) / sizeof(type);       \

  mlib_s32 dll = mlib_ImageGetStride(dst) / sizeof(type);       \

  type*    adr_src = mlib_ImageGetData(src);                    \

  type*    adr_dst = mlib_ImageGetData(dst);                    \

  mlib_s32 chan1 = mlib_ImageGetChannels(src)

/*  mlib_s32 chan2 = chan1 + chan1 */

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

#define DEF_VARS(type)                                          \

  GET_SRC_DST_PARAMETERS(type);                                 \

  type     *sl, *sp, *sl1, *dl, *dp;                            \

  mlib_d64 *pbuff = buff, *buff0, *buff1, *buff2, *buffT;       \

  mlib_s32 i, j, c;                                             \

  mlib_d64 scalef, d0, d1

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

#define DEF_VARS_MxN(type)                                      \

  GET_SRC_DST_PARAMETERS(type);                                 \

  type     *sl, *sp = NULL, *dl, *dp = NULL;                    \

  mlib_d64 *pbuff = buff;                                       \

  mlib_s32 i, j, c

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

#define CALC_SCALE()                                            \

  scalef = 1.0;                                                 \

  while (scalef_expon > 30) {                                   \

    scalef /= (1 << 30);                                        \

    scalef_expon -= 30;                                         \

  }                                                             \

                                                                \

  scalef /= (1 << scalef_expon)

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

#undef  KSIZE

#define KSIZE 2

mlib_status CONV_FUNC(2x2)(mlib_image       *dst,

                           const mlib_image *src,

                           const mlib_s32   *kern,

                           mlib_s32         scalef_expon,

                           mlib_s32         cmask)

{

  mlib_d64 buff[(KSIZE + 1)*BUFF_LINE];

  mlib_d64 k0, k1, k2, k3;

  mlib_d64 p00, p01, p02, p03,

           p10, p11, p12, p13;

  mlib_d64 d2;

  DEF_VARS(mlib_s32);

  mlib_s32 chan2 = chan1 + chan1;

  mlib_s32 chan3 = chan1 + chan2;

  if (wid > BUFF_LINE) {

    pbuff = mlib_malloc((KSIZE + 1)*sizeof(mlib_d64)*wid);

    if (pbuff == NULL) return MLIB_FAILURE;

  }

  buff0 = pbuff;

  buff1 = buff0 + wid;

  buff2 = buff1 + wid;

  wid -= (KSIZE - 1);

  hgt -= (KSIZE - 1);

  /* keep kernel in regs */

  CALC_SCALE();

  k0 = scalef * kern[0];  k1 = scalef * kern[1];

  k2 = scalef * kern[2];  k3 = scalef * kern[3];

  for (c = 0; c < chan1; c++) {

    if (!(cmask & (1 << (chan1 - 1 - c)))) continue;

    sl = adr_src + c;

    dl = adr_dst + c;

    sl1 = sl + sll;

#ifdef __SUNPRO_C

#pragma pipeloop(0)

#endif /* __SUNPRO_C */

    for (i = 0; i < wid + (KSIZE - 1); i++) {

      buff0[i] = (mlib_d64)sl[i*chan1];

      buff1[i] = (mlib_d64)sl1[i*chan1];

    }

    sl += KSIZE*sll;

    for (j = 0; j < hgt; j++) {

      p03 = buff0[0];

      p13 = buff1[0];

      sp = sl;

      dp = dl;

#ifdef __SUNPRO_C

#pragma pipeloop(0)

#endif /* __SUNPRO_C */

      for (i = 0; i <= (wid - 3); i += 3) {

        p00 = p03; p10 = p13;

        p01 = buff0[i + 1]; p11 = buff1[i + 1];

        p02 = buff0[i + 2]; p12 = buff1[i + 2];

        p03 = buff0[i + 3]; p13 = buff1[i + 3];

        buff2[i    ] = (mlib_d64)sp[0];

        buff2[i + 1] = (mlib_d64)sp[chan1];

        buff2[i + 2] = (mlib_d64)sp[chan2];

        d0 = p00 * k0 + p01 * k1 + p10 * k2 + p11 * k3;

        d1 = p01 * k0 + p02 * k1 + p11 * k2 + p12 * k3;

        d2 = p02 * k0 + p03 * k1 + p12 * k2 + p13 * k3;

        CLAMP_S32(dp[0    ], d0);

        CLAMP_S32(dp[chan1], d1);

        CLAMP_S32(dp[chan2], d2);

        sp += chan3;

        dp += chan3;

      }

      for (; i < wid; i++) {

        p00 = buff0[i];     p10 = buff1[i];

        p01 = buff0[i + 1]; p11 = buff1[i + 1];

        buff2[i] = (mlib_d64)sp[0];

        d0 = p00 * k0 + p01 * k1 + p10 * k2 + p11 * k3;

        CLAMP_S32(dp[0], d0);

        sp += chan1;

        dp += chan1;

      }

      buff2[wid] = (mlib_d64)sp[0];

      sl += sll;

      dl += dll;

      buffT = buff0;

      buff0 = buff1;

      buff1 = buff2;

      buff2 = buffT;

    }

  }

  if (pbuff != buff) mlib_free(pbuff);

  return MLIB_SUCCESS;

}

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

#undef  KSIZE

#define KSIZE 3

mlib_status CONV_FUNC(3x3)(mlib_image       *dst,

                           const mlib_image *src,

                           const mlib_s32   *kern,

                           mlib_s32         scalef_expon,

                           mlib_s32         cmask)

{

  mlib_d64 buff[(KSIZE + 1)*BUFF_LINE], *buff3;

  mlib_d64 k0, k1, k2, k3, k4, k5, k6, k7, k8;

  mlib_d64 p00, p01, p02, p03,

           p10, p11, p12, p13,

           p20, p21, p22, p23;

  mlib_s32 *sl2;

  DEF_VARS(mlib_s32);

  mlib_s32 chan2 = chan1 + chan1;

  if (wid > BUFF_LINE) {

    pbuff = mlib_malloc((KSIZE + 1)*sizeof(mlib_d64)*wid);

    if (pbuff == NULL) return MLIB_FAILURE;

  }

  buff0 = pbuff;

  buff1 = buff0 + wid;

  buff2 = buff1 + wid;

  buff3 = buff2 + wid;

  wid -= (KSIZE - 1);

  hgt -= (KSIZE - 1);

  adr_dst += ((KSIZE - 1)/2)*(dll + chan1);

  CALC_SCALE();

  k0 = scalef * kern[0];  k1 = scalef * kern[1];  k2 = scalef * kern[2];

  k3 = scalef * kern[3];  k4 = scalef * kern[4];  k5 = scalef * kern[5];

  k6 = scalef * kern[6];  k7 = scalef * kern[7];  k8 = scalef * kern[8];

  for (c = 0; c < chan1; c++) {

    if (!(cmask & (1 << (chan1 - 1 - c)))) continue;

    sl = adr_src + c;

    dl = adr_dst + c;

    sl1 = sl  + sll;

    sl2 = sl1 + sll;

#ifdef __SUNPRO_C

#pragma pipeloop(0)

#endif /* __SUNPRO_C */

    for (i = 0; i < wid + (KSIZE - 1); i++) {

      buff0[i] = (mlib_d64)sl[i*chan1];

      buff1[i] = (mlib_d64)sl1[i*chan1];

      buff2[i] = (mlib_d64)sl2[i*chan1];

    }

    sl += KSIZE*sll;

    for (j = 0; j < hgt; j++) {

      mlib_d64 s0, s1;

      p02 = buff0[0];

      p12 = buff1[0];

      p22 = buff2[0];

      p03 = buff0[1];

      p13 = buff1[1];

      p23 = buff2[1];

      sp = sl;

      dp = dl;

      s0 = p02 * k0 + p03 * k1 + p12 * k3 + p13 * k4 + p22 * k6 + p23 * k7;

      s1 = p03 * k0 + p13 * k3 + p23 * k6;

#ifdef __SUNPRO_C

#pragma pipeloop(0)

#endif /* __SUNPRO_C */

      for (i = 0; i <= (wid - 2); i += 2) {

        p02 = buff0[i + 2]; p12 = buff1[i + 2]; p22 = buff2[i + 2];

        p03 = buff0[i + 3]; p13 = buff1[i + 3]; p23 = buff2[i + 3];

        buff3[i    ] = (mlib_d64)sp[0];

        buff3[i + 1] = (mlib_d64)sp[chan1];

        d0 = s0 + p02 * k2 + p12 * k5 + p22 * k8;

        d1 = s1 + p02 * k1 + p03 * k2 + p12 * k4 + p13 * k5 + p22 * k7 + p23 * k8;

        CLAMP_S32(dp[0    ], d0);

        CLAMP_S32(dp[chan1], d1);

        s0 = p02 * k0 + p03 * k1 + p12 * k3 + p13 * k4 + p22 * k6 + p23 * k7;

        s1 = p03 * k0 + p13 * k3 + p23 * k6;

        sp += chan2;

        dp += chan2;

      }

      for (; i < wid; i++) {

        p00 = buff0[i];     p10 = buff1[i];     p20 = buff2[i];

        p01 = buff0[i + 1]; p11 = buff1[i + 1]; p21 = buff2[i + 1];

        p02 = buff0[i + 2]; p12 = buff1[i + 2]; p22 = buff2[i + 2];

        buff3[i] = (mlib_d64)sp[0];

        d0 = (p00 * k0 + p01 * k1 + p02 * k2 + p10 * k3 + p11 * k4 +

              p12 * k5 + p20 * k6 + p21 * k7 + p22 * k8);

        CLAMP_S32(dp[0], d0);

        sp += chan1;

        dp += chan1;

      }

      buff3[wid    ] = (mlib_d64)sp[0];

      buff3[wid + 1] = (mlib_d64)sp[chan1];

      sl += sll;

      dl += dll;

      buffT = buff0;

      buff0 = buff1;

      buff1 = buff2;

      buff2 = buff3;

      buff3 = buffT;

    }

  }

  if (pbuff != buff) mlib_free(pbuff);

  return MLIB_SUCCESS;

}

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

#undef  KSIZE

#define KSIZE 4

mlib_status CONV_FUNC(4x4)(mlib_image       *dst,

                           const mlib_image *src,

                           const mlib_s32   *kern,

                           mlib_s32         scalef_expon,

                           mlib_s32         cmask)

{

  mlib_d64 buff[(KSIZE + 2)*BUFF_LINE], *buff3, *buff4, *buff5;

  mlib_d64 k[KSIZE*KSIZE];

  mlib_d64 k0, k1, k2, k3, k4, k5, k6, k7;

  mlib_d64 p00, p01, p02, p03, p04,

           p10, p11, p12, p13, p14,

           p20, p21, p22, p23,

           p30, p31, p32, p33;

  mlib_s32 *sl2, *sl3;

  DEF_VARS(mlib_s32);

  mlib_s32 chan2 = chan1 + chan1;

  if (wid > BUFF_LINE) {

    pbuff = mlib_malloc((KSIZE + 2)*sizeof(mlib_d64)*wid);

    if (pbuff == NULL) return MLIB_FAILURE;

  }

  buff0 = pbuff;

  buff1 = buff0 + wid;

  buff2 = buff1 + wid;

  buff3 = buff2 + wid;

  buff4 = buff3 + wid;

  buff5 = buff4 + wid;

  wid -= (KSIZE - 1);

  hgt -= (KSIZE - 1);

  adr_dst += ((KSIZE - 1)/2)*(dll + chan1);

  CALC_SCALE();

  for (j = 0; j < 16; j++) k[j] = scalef * kern[j];

  for (c = 0; c < chan1; c++) {

    if (!(cmask & (1 << (chan1 - 1 - c)))) continue;

    sl = adr_src + c;

    dl = adr_dst + c;

    sl1 = sl  + sll;

    sl2 = sl1 + sll;

    sl3 = sl2 + sll;

#ifdef __SUNPRO_C

#pragma pipeloop(0)

#endif /* __SUNPRO_C */

    for (i = 0; i < wid + (KSIZE - 1); i++) {

      buff0[i] = (mlib_d64)sl[i*chan1];

      buff1[i] = (mlib_d64)sl1[i*chan1];

      buff2[i] = (mlib_d64)sl2[i*chan1];

      buff3[i] = (mlib_d64)sl3[i*chan1];

    }

    sl += KSIZE*sll;

    for (j = 0; j < hgt; j++) {

      /*

       *  First loop on two first lines of kernel

       */

      k0 = k[0]; k1 = k[1]; k2 = k[2]; k3 = k[3];

      k4 = k[4]; k5 = k[5]; k6 = k[6]; k7 = k[7];

      sp = sl;

      dp = dl;

      p02 = buff0[0];

      p12 = buff1[0];

      p03 = buff0[1];

      p13 = buff1[1];

      p04 = buff0[2];

#ifdef __SUNPRO_C

#pragma pipeloop(0)

#endif /* __SUNPRO_C */

      for (i = 0; i <= (wid - 2); i += 2) {

        p00 = p02; p10 = p12;

        p01 = p03; p11 = p13;

        p02 = p04; p12 = buff1[i + 2];

        p03 = buff0[i + 3]; p13 = buff1[i + 3];

        p04 = buff0[i + 4]; p14 = buff1[i + 4];

        buff4[i] = (mlib_d64)sp[0];

        buff4[i + 1] = (mlib_d64)sp[chan1];

        buff5[i    ] = (p00 * k0 + p01 * k1 + p02 * k2 + p03 * k3 +

                        p10 * k4 + p11 * k5 + p12 * k6 + p13 * k7);

        buff5[i + 1] = (p01 * k0 + p02 * k1 + p03 * k2 + p04 * k3 +

                        p11 * k4 + p12 * k5 + p13 * k6 + p14 * k7);

        sp += chan2;

        dp += chan2;

      }

      /*

       *  Second loop on two last lines of kernel

       */

      k0 = k[ 8]; k1 = k[ 9]; k2 = k[10]; k3 = k[11];

      k4 = k[12]; k5 = k[13]; k6 = k[14]; k7 = k[15];

      sp = sl;

      dp = dl;

      p02 = buff2[0];

      p12 = buff3[0];

      p03 = buff2[1];

      p13 = buff3[1];

      p04 = buff2[2];

#ifdef __SUNPRO_C

#pragma pipeloop(0)

#endif /* __SUNPRO_C */

      for (i = 0; i <= (wid - 2); i += 2) {

        p00 = p02; p10 = p12;

        p01 = p03; p11 = p13;

        p02 = p04; p12 = buff3[i + 2];

        p03 = buff2[i + 3]; p13 = buff3[i + 3];

        p04 = buff2[i + 4]; p14 = buff3[i + 4];

        d0 = (p00 * k0 + p01 * k1 + p02 * k2 + p03 * k3 +

              p10 * k4 + p11 * k5 + p12 * k6 + p13 * k7 + buff5[i]);

        d1 = (p01 * k0 + p02 * k1 + p03 * k2 + p04 * k3 +

              p11 * k4 + p12 * k5 + p13 * k6 + p14 * k7 + buff5[i + 1]);

        CLAMP_S32(dp[0    ], d0);

        CLAMP_S32(dp[chan1], d1);

        sp += chan2;

        dp += chan2;

      }

      /* last pixels */

      for (; i < wid; i++) {

        p00 = buff0[i];     p10 = buff1[i];     p20 = buff2[i];     p30 = buff3[i];

        p01 = buff0[i + 1]; p11 = buff1[i + 1]; p21 = buff2[i + 1]; p31 = buff3[i + 1];

        p02 = buff0[i + 2]; p12 = buff1[i + 2]; p22 = buff2[i + 2]; p32 = buff3[i + 2];

        p03 = buff0[i + 3]; p13 = buff1[i + 3]; p23 = buff2[i + 3]; p33 = buff3[i + 3];

        buff4[i] = (mlib_d64)sp[0];

        d0 = (p00 * k[0] + p01 * k[1] + p02 * k[2] + p03 * k[3] +

              p10 * k[4] + p11 * k[5] + p12 * k[6] + p13 * k[7] +

              p20 * k[ 8] + p21 * k[ 9] + p22 * k[10] + p23 * k[11] +

              p30 * k[12] + p31 * k[13] + p32 * k[14] + p33 * k[15]);

        CLAMP_S32(dp[0], d0);

        sp += chan1;

        dp += chan1;

      }

      buff4[wid    ] = (mlib_d64)sp[0];

      buff4[wid + 1] = (mlib_d64)sp[chan1];

      buff4[wid + 2] = (mlib_d64)sp[chan2];

      /* next line */

      sl += sll;

      dl += dll;

      buffT = buff0;

      buff0 = buff1;

      buff1 = buff2;

      buff2 = buff3;

      buff3 = buff4;

      buff4 = buffT;

    }

  }

  if (pbuff != buff) mlib_free(pbuff);

  return MLIB_SUCCESS;

}

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

#undef  KSIZE