/*

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

 */

/*

 * FUNCTION

 *      mlib_ImageConvMxN - image convolution with edge condition

 *

 * SYNOPSIS

 *      mlib_status mlib_ImageConvMxN(mlib_image       *dst,

 *                                    const mlib_image *src,

 *                                    const mlib_s32   *kernel,

 *                                    mlib_s32         m,

 *                                    mlib_s32         n,

 *                                    mlib_s32         dm,

 *                                    mlib_s32         dn,

 *                                    mlib_s32         scale,

 *                                    mlib_s32         cmask,

 *                                    mlib_edge        edge)

 *

 * ARGUMENTS

 *      dst       Pointer to destination image.

 *      src       Pointer to source image.

 *      m         Kernel width (m must be not less than 1).

 *      n         Kernel height (n must be not less than 1).

 *      dm, dn    Position of key element in convolution kernel.

 *      kernel    Pointer to convolution kernel.

 *      scale     The scaling factor to convert the input integer

 *                coefficients into floating-point coefficients:

 *                floating-point coefficient = integer coefficient * 2^(-scale)

 *      cmask     Channel mask to indicate the channels to be convolved.

 *                Each bit of which represents a channel in the image. The

 *                channels corresponded to 1 bits are those to be processed.

 *      edge      Type of edge condition.

 *

 * DESCRIPTION

 *      2-D convolution, MxN kernel.

 *

 *      The center of the source image is mapped to the center of the

 *      destination image.

 *      The unselected channels are not overwritten. If both src and dst have

 *      just one channel, cmask is ignored.

 *

 *      The edge condition can be one of the following:

 *              MLIB_EDGE_DST_NO_WRITE  (default)

 *              MLIB_EDGE_DST_FILL_ZERO

 *              MLIB_EDGE_DST_COPY_SRC

 *              MLIB_EDGE_SRC_EXTEND

 *

 * RESTRICTION

 *      The src and the dst must be the same type and have same number

 *      of channels (1, 2, 3, or 4).

 *      m >= 1, n >= 1,

 *      0 <= dm < m, 0 <= dn < n.

 *      For data type MLIB_BYTE:   16 <= scale <= 31 (to be compatible with VIS version)

 *      For data type MLIB_USHORT: 17 <= scale <= 32 (to be compatible with VIS version)

 *      For data type MLIB_SHORT:  17 <= scale <= 32 (to be compatible with VIS version)

 *      For data type MLIB_INT:    scale >= 0

 */

#include "mlib_image.h"

#include "mlib_ImageConv.h"

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

static void mlib_ImageConvMxNMulAdd_S32(mlib_d64       *dst,

                                        const mlib_s32 *src,

                                        const mlib_d64 *dkernel,

                                        mlib_s32       n,

                                        mlib_s32       m,

                                        mlib_s32       nch);

static void mlib_ImageConvMxNMedian_S32(mlib_s32 *dst,

                                        mlib_d64 *src,

                                        mlib_s32 n,

                                        mlib_s32 nch);

static void mlib_ImageConvMxNS322S32_ext(mlib_s32       *dst,

                                         const mlib_s32 *src,

                                         mlib_s32       n,

                                         mlib_s32       nch,

                                         mlib_s32       dx_l,

                                         mlib_s32       dx_r);

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

#ifdef MLIB_USE_FTOI_CLAMPING

#define CLAMP_S32(dst, src)                                     \

  dst = (mlib_s32)(src)

#else

#define CLAMP_S32(dst, src) {                                   \

  mlib_d64 s0 = (mlib_d64)(src);                                \

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

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

  dst = (mlib_s32)s0;                                           \

}

#endif /* MLIB_USE_FTOI_CLAMPING */

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

void mlib_ImageConvMxNMulAdd_S32(mlib_d64       *dst,

                                 const mlib_s32 *src,

                                 const mlib_d64 *dkernel,

                                 mlib_s32       n,

                                 mlib_s32       m,

                                 mlib_s32       nch)

{

  mlib_d64 *dst1 = dst + 1;

  mlib_s32 i, j;

  for (j = 0; j < m; j += 3, src += 3 * nch, dkernel += 3) {

    const mlib_s32 *src2 = src + 2 * nch;

    mlib_d64 hval0 = dkernel[0];

    mlib_d64 hval1 = dkernel[1];

    mlib_d64 hval2 = dkernel[2];

    mlib_d64 val0 = src[0];

    mlib_d64 val1 = src[nch];

    mlib_d64 dval = dst[0];

    if (j == m - 2) {

      hval2 = 0.f;

    }

    else if (j == m - 1) {

      hval1 = 0.f;

      hval2 = 0.f;

    }

#ifdef __SUNPRO_C

#pragma pipeloop(0)

#endif /* __SUNPRO_C */

    for (i = 0; i < n; i++) {

      mlib_d64 dval0 = val0 * hval0 + dval;

      mlib_d64 val2 = src2[i * nch];

      dval = dst1[i];

      dval0 += val1 * hval1;

      dval0 += val2 * hval2;

      val0 = val1;

      val1 = val2;

      dst[i] = dval0;

    }

  }

}

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

void mlib_ImageConvMxNMedian_S32(mlib_s32 *dst,

                                 mlib_d64 *src,

                                 mlib_s32 n,

                                 mlib_s32 nch)

{

  mlib_s32 i;

#ifdef __SUNPRO_C

#pragma pipeloop(0)

#endif /* __SUNPRO_C */

  for (i = 0; i < n; i++) {

    mlib_s32 res;

    CLAMP_S32(res, src[i]);

    src[i] = 0.5;

    dst[i * nch] = res;

  }

}

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

void mlib_ImageConvMxNS322S32_ext(mlib_s32       *dst,

                                  const mlib_s32 *src,

                                  mlib_s32       n,

                                  mlib_s32       nch,

                                  mlib_s32       dx_l,

                                  mlib_s32       dx_r)

{

  mlib_s32 i;

  mlib_d64 val = src[0];

  for (i = 0; i < dx_l; i++)

    dst[i] = (mlib_s32) val;

#ifdef __SUNPRO_C

#pragma pipeloop(0)

#endif /* __SUNPRO_C */

  for (; i < n - dx_r; i++)

    dst[i] = src[nch * (i - dx_l)];

  val = dst[n - dx_r - 1];

  for (; i < n; i++)

    dst[i] = (mlib_s32) val;

}

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

mlib_status mlib_convMxNext_s32(mlib_image       *dst,

                                const mlib_image *src,

                                const mlib_s32   *kernel,

                                mlib_s32         m,

                                mlib_s32         n,

                                mlib_s32         dx_l,

                                mlib_s32         dx_r,

                                mlib_s32         dy_t,

                                mlib_s32         dy_b,

                                mlib_s32         scale,

                                mlib_s32         cmask)

{

  mlib_d64 dspace[1024], *dsa = dspace;

  mlib_d64 akernel[256], *dkernel = akernel, fscale = 1.0;

  mlib_s32 wid_e = mlib_ImageGetWidth(src);

  mlib_d64 *dsh, *dsv;

  mlib_s32 *isa;

  mlib_s32 *da = mlib_ImageGetData(dst);

  mlib_s32 *sa = mlib_ImageGetData(src);

  mlib_s32 dlb = mlib_ImageGetStride(dst) >> 2;

  mlib_s32 slb = mlib_ImageGetStride(src) >> 2;

  mlib_s32 dw = mlib_ImageGetWidth(dst);

  mlib_s32 dh = mlib_ImageGetHeight(dst);

  mlib_s32 nch = mlib_ImageGetChannels(dst);

  mlib_s32 i, j, j1, k, mn;

  /* internal buffer */

  if (3 * wid_e + m > 1024) {

    dsa = mlib_malloc((3 * wid_e + m) * sizeof(mlib_d64));

    if (dsa == NULL)

      return MLIB_FAILURE;

  }

  isa = (mlib_s32 *) dsa;

  /* load kernel */

  mn = m * n;

  if (mn > 256) {

    dkernel = mlib_malloc(mn * sizeof(mlib_d64));

      return MLIB_FAILURE;

  }

  while (scale > 30) {

    fscale /= (1 << 30);

    scale -= 30;

  }

  fscale /= (1 << scale);

  for (i = 0; i < mn; i++) {

    dkernel[i] = ((mlib_s32 *) kernel)[i] * fscale;

  }

  dsh = dsa + dw + m;

  dsv = dsh + dw;

  for (i = 0; i < dw; i++) {

    dsh[i] = 0.5;

    dsv[i] = 0.5;

  }

  for (j = 0; j < dh; j++, da += dlb) {

    for (k = 0; k < nch; k++)

      if (cmask & (1 << (nch - 1 - k))) {

        mlib_s32 *sa1 = sa + k;

        mlib_d64 *dkernel1 = dkernel;

        for (j1 = 0; j1 < n; j1++, dkernel1 += m) {

          mlib_ImageConvMxNS322S32_ext(isa, sa1, dw + m - 1, nch, dx_l, dx_r);

          mlib_ImageConvMxNMulAdd_S32(dsh, isa, dkernel1, dw, m, 1);

          if ((j + j1 >= dy_t) && (j + j1 < dh + n - dy_b - 2))

            sa1 += slb;

        }

        mlib_ImageConvMxNMedian_S32(da + k, dsh, dw, nch);

      }

    if ((j >= dy_t) && (j < dh + n - dy_b - 2))

      sa += slb;

  }

  if (dkernel != akernel)

    mlib_free(dkernel);

  if (dsa != dspace)

    mlib_free(dsa);

  return MLIB_SUCCESS;

}

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