/*
 * Image Scaling Functions
 * Copyright (c) 2011 David A. Schleef <ds@schleef.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
/*
 *
 * Modified Lanczos scaling algorithm
 * ==================================
 *
 * This algorithm was developed by the author.  The primary goals of
 * the algorithm are high-quality video downscaling for medium scale
 * factors (in the range of 1.3x to 5.0x) using methods that can be
 * converted to SIMD code.  Concerns with existing algorithms were
 * mainly related to either over-soft filtering (Lanczos) or aliasing
 * (bilinear or any other method with inadequate sampling).
 *
 * The problems with bilinear scaling are apparent when downscaling
 * more than a factor of 2.  For example, when downscaling by a factor
 * of 3, only two-thirds of the input pixels contribute to the output
 * pixels.  This is only considering scaling in one direction; after
 * scaling both vertically and horizontally in a 2-D image, fewer than
 * half of the input pixels contribute to the output, so it should not
 * be surprising that the output is suboptimal.
 *
 * The problems with Lanczos scaling are more subtle.  From a theoretical
 * perspective, Lanczos is an optimal algorithm for resampling equally-
 * spaced values.  This theoretical perspective is based on analysis
 * done in frequency space, thus, Lanczos works very well for audio
 * resampling, since the ear hears primarily in frequency space.  The
 * human visual system is sensitive primarily in the spatial domain,
 * therefore any resampling algorithm should take this into account.
 * This difference is immediately clear in the size of resampling
 * window or envelope that is chosen for resampling: for audio, an
 * envelope of a=64 is typical, in image scaling, the envelope is
 * usually a=2 or a=3.
 *
 * One result of the HVS being sensitive in the spatial domain (and
 * also probably due to oversampling capabilities of the retina and
 * visual cortex) is that it is less sensitive to the exact magnitude
 * of high-frequency visual signals than to the appropriate amount of
 * energy in the nearby frequency band.  A Lanczos kernel with a=2
 * or a=3 strongly decreases the amount of energy in the high frequency
 * bands.  The energy in this area can be increased by increasing a,
 * which brings in energy from different areas of the image (bad for
 * reasons mentioned above), or by oversampling the input data.  We
 * have chosen two methods for doing the latter.  Firstly, there is
 * a sharpness parameter, which increases the cutoff frequency of the
 * filter, aliasing higher frequency noise into the passband.  And
 * secondly, there is the sharpen parameter, which increases the
 * contribution of high-frequency (but in-band) components.
 *
 * An alternate explanation of the usefulness of a sharpening filter
 * is that many natural images have a roughly 1/f spectrum.  In order
 * for a downsampled image to look more "natural" when high frequencies
 * are removed, the frequencies in the pass band near the cutoff
 * frequency are amplified, causing the spectrum to be more roughly
 * 1/f.  I said "roughly", not "literally".
 *
 * This alternate explanation is useful for understanding the author's
 * secondary motivation for developing this algorithm, namely, as a
 * method of video compression.  Several recent techniques (such as
 * HTTP Live Streaming and SVC) use image scaling as a method to get
 * increased compression out of nominally non-scalable codecs such as
 * H.264.  For optimal quality, it is thusly important to consider
 * the scaler and encoder as a combined unit.  Tuning of the sharpness
 * and sharpen parameters was performed using the Toro encoder tuner,
 * where scaled and encoded video was compared to unscaled and encoded
 * video.  This tuning suggested values that were very close to the
 * values chosen by manual inspection of scaled images and video.
 *
 * The optimal values of sharpen and sharpness were slightly different
 * depending whether the comparison was still images or video.  Video
 * comparisons were more sensitive to aliasing, since the aliasing
 * artifacts tended to move or "crawl" around the video.  The default
 * values are for video; image scaling may prefer higher values.
 *
 * A number of related techniques were rejected for various reasons.
 * An early technique of selecting the sharpness factor locally based
 * on edge detection (in order to use a higher sharpness values without
 * the corresponding aliasing on edges) worked very well for still
 * images, but caused too much "crawling" on textures in video.  Also,
 * this method is slow, as it does not parallelize well.
 *
 * Non-separable techniques were rejected because the fastest would
 * have been at least 4x slower.
 *
 * It is infrequently appreciated that image scaling should ideally be
 * done in linear light space.  Converting to linear light space has
 * a similar effect to a sharpening filter.  This approach was not
 * taken because the added benefit is minor compared to the additional
 * computational cost.  Morever, the benefit is decreased by increasing
 * the strength of the sharpening filter.
 *
 */
#include <string.h>

#include "vs_scanline.h"
#include "vs_image.h"

#include "gstvideoscaleorc.h"
#include <gst/gst.h>
#include <math.h>

#define NEED_CLAMP(x,a,b) ((x) < (a) || (x) > (b))

#define ROUND_UP_2(x)  (((x)+1)&~1)
#define ROUND_UP_4(x)  (((x)+3)&~3)
#define ROUND_UP_8(x)  (((x)+7)&~7)

#define SRC_LINE(i) (scale->src->pixels + scale->src->stride * (i))

#define TMP_LINE_S16(i) ((gint16 *)scale->tmpdata + (i)*(scale->dest->width))
#define TMP_LINE_S32(i) ((gint32 *)scale->tmpdata + (i)*(scale->dest->width))
#define TMP_LINE_FLOAT(i) ((float *)scale->tmpdata + (i)*(scale->dest->width))
#define TMP_LINE_DOUBLE(i) ((double *)scale->tmpdata + (i)*(scale->dest->width))
#define TMP_LINE_S16_AYUV(i) ((gint16 *)scale->tmpdata + (i)*4*(scale->dest->width))
#define TMP_LINE_S32_AYUV(i) ((gint32 *)scale->tmpdata + (i)*4*(scale->dest->width))
#define TMP_LINE_FLOAT_AYUV(i) ((float *)scale->tmpdata + (i)*4*(scale->dest->width))
#define TMP_LINE_DOUBLE_AYUV(i) ((double *)scale->tmpdata + (i)*4*(scale->dest->width))

#define PTR_OFFSET(a,b) ((void *)((char *)(a) + (b)))

typedef void (*HorizResampleFunc) (void *dest, const gint32 * offsets,
    const void *taps, const void *src, int n_taps, int shift, int n);

typedef struct _Scale1D Scale1D;
struct _Scale1D
{
  int n;
  double offset;
  double scale;

  double fx;
  double ex;
  int dx;

  int n_taps;
  gint32 *offsets;
  void *taps;
};

typedef struct _Scale Scale;
struct _Scale
{
  const VSImage *dest;
  const VSImage *src;

  double sharpness;
  gboolean dither;

  void *tmpdata;

  HorizResampleFunc horiz_resample_func;

  Scale1D x_scale1d;
  Scale1D y_scale1d;
};

static void
vs_image_scale_lanczos_Y_int16 (const VSImage * dest, const VSImage * src,
    uint8_t * tmpbuf, double sharpness, gboolean dither, double a,
    double sharpen);
static void vs_image_scale_lanczos_Y_int32 (const VSImage * dest,
    const VSImage * src, uint8_t * tmpbuf, double sharpness, gboolean dither,
    double a, double sharpen);
static void vs_image_scale_lanczos_Y_float (const VSImage * dest,
    const VSImage * src, uint8_t * tmpbuf, double sharpness, gboolean dither,
    double a, double sharpen);
static void vs_image_scale_lanczos_Y_double (const VSImage * dest,
    const VSImage * src, uint8_t * tmpbuf, double sharpness, gboolean dither,
    double a, double sharpen);
static void
vs_image_scale_lanczos_AYUV_int16 (const VSImage * dest, const VSImage * src,
    uint8_t * tmpbuf, double sharpness, gboolean dither, double a,
    double sharpen);
static void vs_image_scale_lanczos_AYUV_int32 (const VSImage * dest,
    const VSImage * src, uint8_t * tmpbuf, double sharpness, gboolean dither,
    double a, double sharpen);
static void vs_image_scale_lanczos_AYUV_float (const VSImage * dest,
    const VSImage * src, uint8_t * tmpbuf, double sharpness, gboolean dither,
    double a, double sharpen);
static void vs_image_scale_lanczos_AYUV_double (const VSImage * dest,
    const VSImage * src, uint8_t * tmpbuf, double sharpness, gboolean dither,
    double a, double sharpen);
static void vs_image_scale_lanczos_AYUV64_double (const VSImage * dest,
    const VSImage * src, uint8_t * tmpbuf, double sharpness, gboolean dither,
    double a, double sharpen);

static double
sinc (double x)
{
  if (x == 0)
    return 1;
  return sin (G_PI * x) / (G_PI * x);
}

static double
envelope (double x)
{
  if (x <= -1 || x >= 1)
    return 0;
  return sinc (x);
}

static int
scale1d_get_n_taps (int src_size, int dest_size, double a, double sharpness)
{
  double scale;
  double fx;
  int dx;

  scale = src_size / (double) dest_size;
  if (scale > 1.0) {
    fx = (1.0 / scale) * sharpness;
  } else {
    fx = (1.0) * sharpness;
  }
  dx = ceil (a / fx);

  return 2 * dx;
}

static void
scale1d_cleanup (Scale1D * scale)
{
  g_free (scale->taps);
  g_free (scale->offsets);
}

/*
 * Calculates a set of taps for each destination element in double
 * format.  Each set of taps sums to 1.0.
 *
 */
static void
scale1d_calculate_taps (Scale1D * scale, int src_size, int dest_size,
    int n_taps, double a, double sharpness, double sharpen)
{
  int j;
  double *tap_array;
  gint32 *offsets;
  double scale_offset;
  double scale_increment;
  int dx;
  double fx;
  double ex;

  scale->scale = src_size / (double) dest_size;
  scale->offset = scale->scale / 2 - 0.5;

  if (scale->scale > 1.0) {
    scale->fx = (1.0 / scale->scale) * sharpness;
  } else {
    scale->fx = (1.0) * sharpness;
  }
  scale->ex = scale->fx / a;
  scale->dx = ceil (a / scale->fx);

  g_assert (n_taps >= 2 * scale->dx);
  scale->n_taps = n_taps;

  scale->taps = g_malloc (sizeof (double) * scale->n_taps * dest_size);
  scale->offsets = g_malloc (sizeof (gint32) * dest_size);
  tap_array = scale->taps;
  offsets = scale->offsets;

  scale_offset = scale->offset;
  scale_increment = scale->scale;
  dx = scale->dx;
  fx = scale->fx;
  ex = scale->ex;

  for (j = 0; j < dest_size; j++) {
    double x;
    int xi;
    int l;
    double weight;
    double *taps;

    x = scale_offset + scale_increment * j;
    x = CLAMP (x, 0, src_size);
    xi = ceil (x) - dx;

    offsets[j] = xi;
    weight = 0;
    taps = tap_array + j * n_taps;

    for (l = 0; l < n_taps; l++) {
      int xl = xi + l;
      taps[l] = sinc ((x - xl) * fx) * envelope ((x - xl) * ex);
      taps[l] -= sharpen * envelope ((x - xl) * ex);
      weight += taps[l];
    }
    g_assert (envelope ((x - (xi - 1)) * ex) == 0);
    g_assert (envelope ((x - (xi + n_taps)) * ex) == 0);
    for (l = 0; l < n_taps; l++) {
      taps[l] /= weight;
    }

    if (xi < 0) {
      int shift = -xi;

      for (l = 0; l < shift; l++) {
        taps[shift] += taps[l];
      }
      for (l = 0; l < n_taps - shift; l++) {
        taps[l] = taps[shift + l];
      }
      for (; l < n_taps; l++) {
        taps[l] = 0;
      }
      offsets[j] += shift;
    }

    if (xi > src_size - n_taps) {
      int shift = xi - (src_size - n_taps);

      for (l = 0; l < shift; l++) {
        taps[n_taps - shift - 1] += taps[n_taps - shift + l];
      }
      for (l = 0; l < n_taps - shift; l++) {
        taps[n_taps - 1 - l] = taps[n_taps - 1 - shift - l];
      }
      for (l = 0; l < shift; l++) {
        taps[l] = 0;
      }
      offsets[j] -= shift;
    }
  }
}

/*
 * Calculates a set of taps for each destination element in float
 * format.  Each set of taps sums to 1.0.
 */
static void
scale1d_calculate_taps_float (Scale1D * scale, int src_size, int dest_size,
    int n_taps, double a, double sharpness, double sharpen)
{
  double *taps_d;
  float *taps_f;
  int j;

  scale1d_calculate_taps (scale, src_size, dest_size, n_taps, a, sharpness,
      sharpen);

  taps_d = scale->taps;
  taps_f = g_malloc (sizeof (float) * scale->n_taps * dest_size);

  for (j = 0; j < dest_size * n_taps; j++) {
    taps_f[j] = taps_d[j];
  }

  g_free (taps_d);
  scale->taps = taps_f;
}

/*
 * Calculates a set of taps for each destination element in gint32
 * format.  Each set of taps sums to (very nearly) (1<<shift).  A
 * typical value for shift is 10 to 15, so that applying the taps to
 * uint8 values and summing will fit in a (signed) int32.
 */
static void
scale1d_calculate_taps_int32 (Scale1D * scale, int src_size, int dest_size,
    int n_taps, double a, double sharpness, double sharpen, int shift)
{
  double *taps_d;
  gint32 *taps_i;
  int i;
  int j;
  double multiplier;

  scale1d_calculate_taps (scale, src_size, dest_size, n_taps, a, sharpness,
      sharpen);

  taps_d = scale->taps;
  taps_i = g_malloc (sizeof (gint32) * scale->n_taps * dest_size);

  multiplier = (1 << shift);

  for (j = 0; j < dest_size; j++) {
    for (i = 0; i < n_taps; i++) {
      taps_i[j * n_taps + i] =
          floor (0.5 + taps_d[j * n_taps + i] * multiplier);
    }
  }

  g_free (taps_d);
  scale->taps = taps_i;
}

/*
 * Calculates a set of taps for each destination element in gint16
 * format.  Each set of taps sums to (1<<shift).  A typical value
 * for shift is 7, so that applying the taps to uint8 values and
 * summing will fit in a (signed) int16.
 */
static void
scale1d_calculate_taps_int16 (Scale1D * scale, int src_size, int dest_size,
    int n_taps, double a, double sharpness, double sharpen, int shift)
{
  double *taps_d;
  gint16 *taps_i;
  int i;
  int j;
  double multiplier;

  scale1d_calculate_taps (scale, src_size, dest_size, n_taps, a, sharpness,
      sharpen);

  taps_d = scale->taps;
  taps_i = g_malloc (sizeof (gint16) * scale->n_taps * dest_size);

  multiplier = (1 << shift);

  /* Various methods for converting floating point taps to integer.
   * The dB values are the SSIM value between scaling an image via
   * the floating point pathway vs. the integer pathway using the
   * given code to generate the taps.  Only one image was tested,
   * scaling from 1920x1080 to 640x360.  Several variations of the
   * methods were also tested, with nothing appearing useful.  */
#if 0
  /* Standard round to integer.  This causes bad DC errors. */
  /* 44.588 dB */
  for (j = 0; j < dest_size; j++) {
    for (i = 0; i < n_taps; i++) {
      taps_i[j * n_taps + i] =
          floor (0.5 + taps_d[j * n_taps + i] * multiplier);
    }
  }
#endif
#if 0
  /* Dithering via error propogation.  Works pretty well, but
   * really we want to propogate errors across rows, which would
   * mean having several sets of tap arrays.  Possible, but more work,
   * and it may not even be better. */
  /* 57.0961 dB */
  {
    double err = 0;
    for (j = 0; j < dest_size; j++) {
      for (i = 0; i < n_taps; i++) {
        err += taps_d[j * n_taps + i] * multiplier;
        taps_i[j * n_taps + i] = floor (err);
        err -= floor (err);
      }
    }
  }
#endif
#if 1
  /* Round to integer, but with an adjustable bias that we use to
   * eliminate the DC error.  This search method is a bit crude, and
   * could perhaps be improved somewhat. */
  /* 60.4851 dB */
  for (j = 0; j < dest_size; j++) {
    int k;
    for (k = 0; k < 100; k++) {
      int sum = 0;
      double offset;

      offset = k * 0.01;
      for (i = 0; i < n_taps; i++) {
        taps_i[j * n_taps + i] =
            floor (offset + taps_d[j * n_taps + i] * multiplier);
        sum += taps_i[j * n_taps + i];
      }

      if (sum >= (1 << shift))
        break;
    }
  }
#endif
#if 0
  /* Round to integer, but adjust the multiplier.  The search method is
   * wrong a lot, but was sufficient enough to calculate dB error. */
  /* 58.6517 dB */
  for (j = 0; j < dest_size; j++) {
    int k;
    int sum = 0;
    for (k = 0; k < 200; k++) {
      sum = 0;

      multiplier = (1 << shift) - 1.0 + k * 0.01;
      for (i = 0; i < n_taps; i++) {
        taps_i[j * n_taps + i] =
            floor (0.5 + taps_d[j * n_taps + i] * multiplier);
        sum += taps_i[j * n_taps + i];
      }

      if (sum >= (1 << shift))
        break;
    }
    if (sum != (1 << shift)) {
      GST_ERROR ("%g %d", multiplier, sum);
    }
  }
#endif
#if 0
  /* Round to integer, but subtract the error from the largest tap */
  /* 58.3677 dB */
  for (j = 0; j < dest_size; j++) {
    int err = -multiplier;
    for (i = 0; i < n_taps; i++) {
      taps_i[j * n_taps + i] =
          floor (0.5 + taps_d[j * n_taps + i] * multiplier);
      err += taps_i[j * n_taps + i];
    }
    if (taps_i[j * n_taps + (n_taps / 2 - 1)] >
        taps_i[j * n_taps + (n_taps / 2)]) {
      taps_i[j * n_taps + (n_taps / 2 - 1)] -= err;
    } else {
      taps_i[j * n_taps + (n_taps / 2)] -= err;
    }
  }
#endif

  g_free (taps_d);
  scale->taps = taps_i;
}


void
vs_image_scale_lanczos_Y (const VSImage * dest, const VSImage * src,
    uint8_t * tmpbuf, double sharpness, gboolean dither, int submethod,
    double a, double sharpen)
{
  switch (submethod) {
    case 0:
    default:
      vs_image_scale_lanczos_Y_int16 (dest, src, tmpbuf, sharpness, dither, a,
          sharpen);
      break;
    case 1:
      vs_image_scale_lanczos_Y_int32 (dest, src, tmpbuf, sharpness, dither, a,
          sharpen);
      break;
    case 2:
      vs_image_scale_lanczos_Y_float (dest, src, tmpbuf, sharpness, dither, a,
          sharpen);
      break;
    case 3:
      vs_image_scale_lanczos_Y_double (dest, src, tmpbuf, sharpness, dither, a,
          sharpen);
      break;
  }
}

void
vs_image_scale_lanczos_AYUV (const VSImage * dest, const VSImage * src,
    uint8_t * tmpbuf, double sharpness, gboolean dither, int submethod,
    double a, double sharpen)
{
  switch (submethod) {
    case 0:
    default:
      vs_image_scale_lanczos_AYUV_int16 (dest, src, tmpbuf, sharpness, dither,
          a, sharpen);
      break;
    case 1:
      vs_image_scale_lanczos_AYUV_int32 (dest, src, tmpbuf, sharpness, dither,
          a, sharpen);
      break;
    case 2:
      vs_image_scale_lanczos_AYUV_float (dest, src, tmpbuf, sharpness, dither,
          a, sharpen);
      break;
    case 3:
      vs_image_scale_lanczos_AYUV_double (dest, src, tmpbuf, sharpness, dither,
          a, sharpen);
      break;
  }
}

void
vs_image_scale_lanczos_AYUV64 (const VSImage * dest, const VSImage * src,
    uint8_t * tmpbuf, double sharpness, gboolean dither, int submethod,
    double a, double sharpen)
{
  vs_image_scale_lanczos_AYUV64_double (dest, src, tmpbuf, sharpness, dither,
      a, sharpen);
}



#define RESAMPLE_HORIZ_FLOAT(function, dest_type, tap_type, src_type, _n_taps) \
static void \
function (dest_type *dest, const gint32 *offsets, \
    const tap_type *taps, const src_type *src, int n_taps, int shift, int n) \
{ \
  int i; \
  int k; \
  dest_type sum; \
  const src_type *srcline; \
  const tap_type *tapsline; \
  for (i = 0; i < n; i++) { \
    srcline = src + offsets[i]; \
    tapsline = taps + i * _n_taps; \
    sum = 0; \
    for (k = 0; k < _n_taps; k++) { \
      sum += srcline[k] * tapsline[k]; \
    } \
    dest[i] = sum; \
  } \
}

#define RESAMPLE_HORIZ(function, dest_type, tap_type, src_type, _n_taps, _shift) \
static void \
function (dest_type *dest, const gint32 *offsets, \
    const tap_type *taps, const src_type *src, int n_taps, int shift, int n) \
{ \
  int i; \
  int k; \
  dest_type sum; \
  const src_type *srcline; \
  const tap_type *tapsline; \
  int offset; \
  if (_shift > 0) offset = (1<<_shift)>>1; \
  else offset = 0; \
  for (i = 0; i < n; i++) { \
    srcline = src + offsets[i]; \
    tapsline = taps + i * _n_taps; \
    sum = 0; \
    for (k = 0; k < _n_taps; k++) { \
      sum += srcline[k] * tapsline[k]; \
    } \
    dest[i] = (sum + offset) >> _shift; \
  } \
}

#define RESAMPLE_HORIZ_AYUV_FLOAT(function, dest_type, tap_type, src_type, _n_taps) \
static void \
function (dest_type *dest, const gint32 *offsets, \
    const tap_type *taps, const src_type *src, int n_taps, int shift, int n) \
{ \
  int i; \
  int k; \
  dest_type sum1; \
  dest_type sum2; \
  dest_type sum3; \
  dest_type sum4; \
  const src_type *srcline; \
  const tap_type *tapsline; \
  for (i = 0; i < n; i++) { \
    srcline = src + 4*offsets[i]; \
    tapsline = taps + i * _n_taps; \
    sum1 = 0; \
    sum2 = 0; \
    sum3 = 0; \
    sum4 = 0; \
    for (k = 0; k < _n_taps; k++) { \
      sum1 += srcline[k*4+0] * tapsline[k]; \
      sum2 += srcline[k*4+1] * tapsline[k]; \
      sum3 += srcline[k*4+2] * tapsline[k]; \
      sum4 += srcline[k*4+3] * tapsline[k]; \
    } \
    dest[i*4+0] = sum1; \
    dest[i*4+1] = sum2; \
    dest[i*4+2] = sum3; \
    dest[i*4+3] = sum4; \
  } \
}

#define RESAMPLE_HORIZ_AYUV(function, dest_type, tap_type, src_type, _n_taps, _shift) \
static void \
function (dest_type *dest, const gint32 *offsets, \
    const tap_type *taps, const src_type *src, int n_taps, int shift, int n) \
{ \
  int i; \
  int k; \
  dest_type sum1; \
  dest_type sum2; \
  dest_type sum3; \
  dest_type sum4; \
  const src_type *srcline; \
  const tap_type *tapsline; \
  int offset; \
  if (_shift > 0) offset = (1<<_shift)>>1; \
  else offset = 0; \
  for (i = 0; i < n; i++) { \
    srcline = src + 4*offsets[i]; \
    tapsline = taps + i * _n_taps; \
    sum1 = 0; \
    sum2 = 0; \
    sum3 = 0; \
    sum4 = 0; \
    for (k = 0; k < _n_taps; k++) { \
      sum1 += srcline[k*4+0] * tapsline[k]; \
      sum2 += srcline[k*4+1] * tapsline[k]; \
      sum3 += srcline[k*4+2] * tapsline[k]; \
      sum4 += srcline[k*4+3] * tapsline[k]; \
    } \
    dest[i*4+0] = (sum1 + offset) >> _shift; \
    dest[i*4+1] = (sum2 + offset) >> _shift; \
    dest[i*4+2] = (sum3 + offset) >> _shift; \
    dest[i*4+3] = (sum4 + offset) >> _shift; \
  } \
}

/* *INDENT-OFF* */
RESAMPLE_HORIZ_FLOAT (resample_horiz_double_u8_generic, double, double,
    guint8, n_taps)
RESAMPLE_HORIZ_FLOAT (resample_horiz_float_u8_generic, float, float,
    guint8, n_taps)
RESAMPLE_HORIZ_AYUV_FLOAT (resample_horiz_double_ayuv_generic, double, double,
    guint8, n_taps)
RESAMPLE_HORIZ_AYUV_FLOAT (resample_horiz_float_ayuv_generic, float, float,
    guint8, n_taps)

RESAMPLE_HORIZ_AYUV_FLOAT (resample_horiz_double_ayuv_generic_s16, double, double,
    guint16, n_taps)

RESAMPLE_HORIZ (resample_horiz_int32_int32_u8_generic, gint32, gint32,
    guint8, n_taps, shift)
RESAMPLE_HORIZ (resample_horiz_int16_int16_u8_generic, gint16, gint16,
    guint8, n_taps, shift)
RESAMPLE_HORIZ_AYUV (resample_horiz_int32_int32_ayuv_generic, gint32, gint32,
    guint8, n_taps, shift)
RESAMPLE_HORIZ_AYUV (resample_horiz_int16_int16_ayuv_generic, gint16, gint16,
    guint8, n_taps, shift)

/* Candidates for orcification */
RESAMPLE_HORIZ (resample_horiz_int32_int32_u8_taps16_shift0, gint32, gint32,
    guint8, 16, 0)
RESAMPLE_HORIZ (resample_horiz_int32_int32_u8_taps12_shift0, gint32, gint32,
    guint8, 12, 0)
RESAMPLE_HORIZ (resample_horiz_int32_int32_u8_taps8_shift0, gint32, gint32,
    guint8, 8, 0)
RESAMPLE_HORIZ (resample_horiz_int32_int32_u8_taps4_shift0, gint32, gint32,
    guint8, 4, 0)
RESAMPLE_HORIZ (resample_horiz_int16_int16_u8_taps16_shift0, gint16, gint16,
    guint8, 16, 0)
RESAMPLE_HORIZ (resample_horiz_int16_int16_u8_taps12_shift0, gint16, gint16,
    guint8, 12, 0)
RESAMPLE_HORIZ (resample_horiz_int16_int16_u8_taps8_shift0, gint16, gint16,
    guint8, 8, 0)
RESAMPLE_HORIZ (resample_horiz_int16_int16_u8_taps4_shift0, gint16, gint16,
    guint8, 4, 0)

RESAMPLE_HORIZ_AYUV (resample_horiz_int32_int32_ayuv_taps16_shift0, gint32, gint32,
    guint8, 16, 0)
RESAMPLE_HORIZ_AYUV (resample_horiz_int32_int32_ayuv_taps12_shift0, gint32, gint32,
    guint8, 12, 0)
RESAMPLE_HORIZ_AYUV (resample_horiz_int32_int32_ayuv_taps8_shift0, gint32, gint32,
    guint8, 8, 0)
RESAMPLE_HORIZ_AYUV (resample_horiz_int32_int32_ayuv_taps4_shift0, gint32, gint32,
    guint8, 4, 0)
RESAMPLE_HORIZ_AYUV (resample_horiz_int16_int16_ayuv_taps16_shift0, gint16, gint16,
    guint8, 16, 0)
RESAMPLE_HORIZ_AYUV (resample_horiz_int16_int16_ayuv_taps12_shift0, gint16, gint16,
    guint8, 12, 0)
RESAMPLE_HORIZ_AYUV (resample_horiz_int16_int16_ayuv_taps8_shift0, gint16, gint16,
    guint8, 8, 0)
RESAMPLE_HORIZ_AYUV (resample_horiz_int16_int16_ayuv_taps4_shift0, gint16, gint16,
    guint8, 4, 0)
/* *INDENT-ON* */

#define RESAMPLE_VERT(function, tap_type, src_type, _n_taps, _shift) \
static void \
function (guint8 *dest, \
    const tap_type *taps, const src_type *src, int stride, int n_taps, \
    int shift, int n) \
{ \
  int i; \
  int l; \
  gint32 sum_y; \
  gint32 offset = (1<<_shift) >> 1; \
  for (i = 0; i < n; i++) { \
    sum_y = 0; \
    for (l = 0; l < n_taps; l++) { \
      const src_type *line = PTR_OFFSET(src, stride * l); \
      sum_y += line[i] * taps[l]; \
    } \
    dest[i] = CLAMP ((sum_y + offset) >> _shift, 0, 255); \
  } \
}

#define RESAMPLE_VERT_DITHER(function, tap_type, src_type, _n_taps, _shift) \
static void \
function (guint8 *dest, \
    const tap_type *taps, const src_type *src, int stride, int n_taps, \
    int shift, int n) \
{ \
  int i; \
  int l; \
  gint32 sum_y; \
  gint32 err_y = 0; \
  gint32 mask = (1<<_shift) - 1; \
  for (i = 0; i < n; i++) { \
    sum_y = 0; \
    for (l = 0; l < n_taps; l++) { \
      const src_type *line = PTR_OFFSET(src, stride * l); \
      sum_y += line[i] * taps[l]; \
    } \
    err_y += sum_y; \
    dest[i] = CLAMP (err_y >> _shift, 0, 255); \
    err_y &= mask; \
  } \
}

/* *INDENT-OFF* */
RESAMPLE_VERT (resample_vert_int32_generic, gint32, gint32, n_taps, shift)
RESAMPLE_VERT_DITHER (resample_vert_dither_int32_generic, gint32, gint32,
    n_taps, shift)
RESAMPLE_VERT (resample_vert_int16_generic, gint16, gint16, n_taps, shift);
RESAMPLE_VERT_DITHER (resample_vert_dither_int16_generic, gint16, gint16,
    n_taps, shift)
/* *INDENT-ON* */

#define RESAMPLE_VERT_FLOAT(function, dest_type, clamp, tap_type, src_type, _n_taps, _shift) \
static void \
function (dest_type *dest, \
    const tap_type *taps, const src_type *src, int stride, int n_taps, \
    int shift, int n) \
{ \
  int i; \
  int l; \
  src_type sum_y; \
  for (i = 0; i < n; i++) { \
    sum_y = 0; \
    for (l = 0; l < n_taps; l++) { \
      const src_type *line = PTR_OFFSET(src, stride * l); \
      sum_y += line[i] * taps[l]; \
    } \
    dest[i] = CLAMP (floor(0.5 + sum_y), 0, clamp); \
  } \
}

#define RESAMPLE_VERT_FLOAT_DITHER(function, dest_type, clamp, tap_type, src_type, _n_taps, _shift) \
static void \
function (dest_type *dest, \
    const tap_type *taps, const src_type *src, int stride, int n_taps, \
    int shift, int n) \
{ \
  int i; \
  int l; \
  src_type sum_y; \
  src_type err_y = 0; \
  for (i = 0; i < n; i++) { \
    sum_y = 0; \
    for (l = 0; l < n_taps; l++) { \
      const src_type *line = PTR_OFFSET(src, stride * l); \
      sum_y += line[i] * taps[l]; \
    } \
    err_y += sum_y; \
    dest[i] = CLAMP (floor (err_y), 0, clamp); \
    err_y -= floor (err_y); \
  } \
}

/* *INDENT-OFF* */
RESAMPLE_VERT_FLOAT (resample_vert_double_generic, guint8, 255, double, double, n_taps,
    shift)
RESAMPLE_VERT_FLOAT_DITHER (resample_vert_dither_double_generic, guint8, 255, double, double,
    n_taps, shift)

RESAMPLE_VERT_FLOAT (resample_vert_double_generic_u16, guint16, 65535, double, double, n_taps,
    shift)
RESAMPLE_VERT_FLOAT_DITHER (resample_vert_dither_double_generic_u16, guint16, 65535, double, double,
    n_taps, shift)

RESAMPLE_VERT_FLOAT (resample_vert_float_generic, guint8, 255, float, float, n_taps, shift)
RESAMPLE_VERT_FLOAT_DITHER (resample_vert_dither_float_generic, guint8, 255, float, float,
    n_taps, shift)
/* *INDENT-ON* */

#define S16_SHIFT1 7
#define S16_SHIFT2 7
#define S16_MIDSHIFT 0
#define S16_POSTSHIFT (S16_SHIFT1+S16_SHIFT2-S16_MIDSHIFT)

static void
vs_scale_lanczos_Y_int16 (Scale * scale)
{
  int j;
  int yi;
  int tmp_yi;

  tmp_yi = 0;

  for (j = 0; j < scale->dest->height; j++) {
    guint8 *destline;
    gint16 *taps;

    destline = scale->dest->pixels + scale->dest->stride * j;

    yi = scale->y_scale1d.offsets[j];

    while (tmp_yi < yi + scale->y_scale1d.n_taps) {
      scale->horiz_resample_func (TMP_LINE_S16 (tmp_yi),
          scale->x_scale1d.offsets, scale->x_scale1d.taps, SRC_LINE (tmp_yi),
          scale->x_scale1d.n_taps, S16_MIDSHIFT, scale->dest->width);
      tmp_yi++;
    }

    taps = (gint16 *) scale->y_scale1d.taps + j * scale->y_scale1d.n_taps;
    if (scale->dither) {
      resample_vert_dither_int16_generic (destline,
          taps, TMP_LINE_S16 (scale->y_scale1d.offsets[j]),
          sizeof (gint16) * scale->dest->width, scale->y_scale1d.n_taps,
          S16_POSTSHIFT, scale->dest->width);
    } else {
      resample_vert_int16_generic (destline,
          taps, TMP_LINE_S16 (scale->y_scale1d.offsets[j]),
          sizeof (gint16) * scale->dest->width, scale->y_scale1d.n_taps,
          S16_POSTSHIFT, scale->dest->width);
    }
  }
}

void
vs_image_scale_lanczos_Y_int16 (const VSImage * dest, const VSImage * src,
    uint8_t * tmpbuf, double sharpness, gboolean dither, double a,
    double sharpen)
{
  Scale s = { 0 };
  Scale *scale = &s;
  int n_taps;

  scale->dest = dest;
  scale->src = src;

  n_taps = scale1d_get_n_taps (src->width, dest->width, a, sharpness);
  n_taps = ROUND_UP_4 (n_taps);
  scale1d_calculate_taps_int16 (&scale->x_scale1d,
      src->width, dest->width, n_taps, a, sharpness, sharpen, S16_SHIFT1);

  n_taps = scale1d_get_n_taps (src->height, dest->height, a, sharpness);
  scale1d_calculate_taps_int16 (&scale->y_scale1d,
      src->height, dest->height, n_taps, a, sharpness, sharpen, S16_SHIFT2);

  scale->dither = dither;

  switch (scale->x_scale1d.n_taps) {
    case 4:
      scale->horiz_resample_func =
          (HorizResampleFunc) resample_horiz_int16_int16_u8_taps4_shift0;
      break;
    case 8:
      scale->horiz_resample_func =
          (HorizResampleFunc) resample_horiz_int16_int16_u8_taps8_shift0;
      break;
    case 12:
      scale->horiz_resample_func =
          (HorizResampleFunc) resample_horiz_int16_int16_u8_taps12_shift0;
      break;
    case 16:
      scale->horiz_resample_func =
          (HorizResampleFunc) resample_horiz_int16_int16_u8_taps16_shift0;
      break;
    default:
      scale->horiz_resample_func =
          (HorizResampleFunc) resample_horiz_int16_int16_u8_generic;
      break;
  }

  scale->tmpdata =
      g_malloc (sizeof (gint16) * scale->dest->width * scale->src->height);

  vs_scale_lanczos_Y_int16 (scale);

  scale1d_cleanup (&scale->x_scale1d);
  scale1d_cleanup (&scale->y_scale1d);
  g_free (scale->tmpdata);
}


#define S32_SHIFT1 11
#define S32_SHIFT2 11
#define S32_MIDSHIFT 0
#define S32_POSTSHIFT (S32_SHIFT1+S32_SHIFT2-S32_MIDSHIFT)

static void
vs_scale_lanczos_Y_int32 (Scale * scale)
{
  int j;
  int yi;
  int tmp_yi;

  tmp_yi = 0;

  for (j = 0; j < scale->dest->height; j++) {
    guint8 *destline;
    gint32 *taps;

    destline = scale->dest->pixels + scale->dest->stride * j;

    yi = scale->y_scale1d.offsets[j];

    while (tmp_yi < yi + scale->y_scale1d.n_taps) {
      scale->horiz_resample_func (TMP_LINE_S32 (tmp_yi),
          scale->x_scale1d.offsets, scale->x_scale1d.taps, SRC_LINE (tmp_yi),
          scale->x_scale1d.n_taps, S32_MIDSHIFT, scale->dest->width);
      tmp_yi++;
    }

    taps = (gint32 *) scale->y_scale1d.taps + j * scale->y_scale1d.n_taps;
    if (scale->dither) {
      resample_vert_dither_int32_generic (destline,
          taps, TMP_LINE_S32 (scale->y_scale1d.offsets[j]),
          sizeof (gint32) * scale->dest->width,
          scale->y_scale1d.n_taps, S32_POSTSHIFT, scale->dest->width);
    } else {
      resample_vert_int32_generic (destline,
          taps, TMP_LINE_S32 (scale->y_scale1d.offsets[j]),
          sizeof (gint32) * scale->dest->width,
          scale->y_scale1d.n_taps, S32_POSTSHIFT, scale->dest->width);
    }
  }
}

void
vs_image_scale_lanczos_Y_int32 (const VSImage * dest, const VSImage * src,
    uint8_t * tmpbuf, double sharpness, gboolean dither, double a,
    double sharpen)
{
  Scale s = { 0 };
  Scale *scale = &s;
  int n_taps;

  scale->dest = dest;
  scale->src = src;

  n_taps = scale1d_get_n_taps (src->width, dest->width, a, sharpness);
  n_taps = ROUND_UP_4 (n_taps);
  scale1d_calculate_taps_int32 (&scale->x_scale1d,
      src->width, dest->width, n_taps, a, sharpness, sharpen, S32_SHIFT1);

  n_taps = scale1d_get_n_taps (src->height, dest->height, a, sharpness);
  scale1d_calculate_taps_int32 (&scale->y_scale1d,
      src->height, dest->height, n_taps, a, sharpness, sharpen, S32_SHIFT2);

  scale->dither = dither;

  switch (scale->x_scale1d.n_taps) {
    case 4:
      scale->horiz_resample_func =
          (HorizResampleFunc) resample_horiz_int32_int32_u8_taps4_shift0;
      break;
    case 8:
      scale->horiz_resample_func =
          (HorizResampleFunc) resample_horiz_int32_int32_u8_taps8_shift0;
      break;
    case 12:
      scale->horiz_resample_func =
          (HorizResampleFunc) resample_horiz_int32_int32_u8_taps12_shift0;
      break;
    case 16:
      scale->horiz_resample_func =
          (HorizResampleFunc) resample_horiz_int32_int32_u8_taps16_shift0;
      break;
    default:
      scale->horiz_resample_func =
          (HorizResampleFunc) resample_horiz_int32_int32_u8_generic;
      break;
  }

  scale->tmpdata =
      g_malloc (sizeof (int32_t) * scale->dest->width * scale->src->height);

  vs_scale_lanczos_Y_int32 (scale);

  scale1d_cleanup (&scale->x_scale1d);
  scale1d_cleanup (&scale->y_scale1d);
  g_free (scale->tmpdata);
}

static void
vs_scale_lanczos_Y_double (Scale * scale)
{
  int j;
  int yi;
  int tmp_yi;

  tmp_yi = 0;

  for (j = 0; j < scale->dest->height; j++) {
    guint8 *destline;
    double *taps;

    destline = scale->dest->pixels + scale->dest->stride * j;

    yi = scale->y_scale1d.offsets[j];

    while (tmp_yi < yi + scale->y_scale1d.n_taps) {
      scale->horiz_resample_func (TMP_LINE_DOUBLE (tmp_yi),
          scale->x_scale1d.offsets, scale->x_scale1d.taps, SRC_LINE (tmp_yi),
          scale->x_scale1d.n_taps, 0, scale->dest->width);
      tmp_yi++;
    }

    taps = (double *) scale->y_scale1d.taps + j * scale->y_scale1d.n_taps;
    if (scale->dither) {
      resample_vert_dither_double_generic (destline,
          taps, TMP_LINE_DOUBLE (scale->y_scale1d.offsets[j]),
          sizeof (double) * scale->dest->width,
          scale->y_scale1d.n_taps, 0, scale->dest->width);
    } else {
      resample_vert_double_generic (destline,
          taps, TMP_LINE_DOUBLE (scale->y_scale1d.offsets[j]),
          sizeof (double) * scale->dest->width,
          scale->y_scale1d.n_taps, 0, scale->dest->width);
    }
  }
}

void
vs_image_scale_lanczos_Y_double (const VSImage * dest, const VSImage * src,
    uint8_t * tmpbuf, double sharpness, gboolean dither, double a,
    double sharpen)
{
  Scale s = { 0 };
  Scale *scale = &s;
  int n_taps;

  scale->dest = dest;
  scale->src = src;

  n_taps = scale1d_get_n_taps (src->width, dest->width, a, sharpness);
  scale1d_calculate_taps (&scale->x_scale1d,
      src->width, dest->width, n_taps, a, sharpness, sharpen);

  n_taps = scale1d_get_n_taps (src->height, dest->height, a, sharpness);
  scale1d_calculate_taps (&scale->y_scale1d,
      src->height, dest->height, n_taps, a, sharpness, sharpen);

  scale->dither = dither;

  scale->horiz_resample_func =
      (HorizResampleFunc) resample_horiz_double_u8_generic;

  scale->tmpdata =
      g_malloc (sizeof (double) * scale->dest->width * scale->src->height);

  vs_scale_lanczos_Y_double (scale);

  scale1d_cleanup (&scale->x_scale1d);
  scale1d_cleanup (&scale->y_scale1d);
  g_free (scale->tmpdata);
}

static void
vs_scale_lanczos_Y_float (Scale * scale)
{
  int j;
  int yi;
  int tmp_yi;

  tmp_yi = 0;

  for (j = 0; j < scale->dest->height; j++) {
    guint8 *destline;
    float *taps;

    destline = scale->dest->pixels + scale->dest->stride * j;

    yi = scale->y_scale1d.offsets[j];

    while (tmp_yi < yi + scale->y_scale1d.n_taps) {
      scale->horiz_resample_func (TMP_LINE_FLOAT (tmp_yi),
          scale->x_scale1d.offsets, scale->x_scale1d.taps, SRC_LINE (tmp_yi),
          scale->x_scale1d.n_taps, 0, scale->dest->width);
      tmp_yi++;
    }

    taps = (float *) scale->y_scale1d.taps + j * scale->y_scale1d.n_taps;
    if (scale->dither) {
      resample_vert_dither_float_generic (destline,
          taps, TMP_LINE_FLOAT (scale->y_scale1d.offsets[j]),
          sizeof (float) * scale->dest->width,
          scale->y_scale1d.n_taps, 0, scale->dest->width);
    } else {
      resample_vert_float_generic (destline,
          taps, TMP_LINE_FLOAT (scale->y_scale1d.offsets[j]),
          sizeof (float) * scale->dest->width,
          scale->y_scale1d.n_taps, 0, scale->dest->width);
    }
  }
}

void
vs_image_scale_lanczos_Y_float (const VSImage * dest, const VSImage * src,
    uint8_t * tmpbuf, double sharpness, gboolean dither, double a,
    double sharpen)
{
  Scale s = { 0 };
  Scale *scale = &s;
  int n_taps;

  scale->dest = dest;
  scale->src = src;

  n_taps = scale1d_get_n_taps (src->width, dest->width, a, sharpness);
  scale1d_calculate_taps_float (&scale->x_scale1d,
      src->width, dest->width, n_taps, a, sharpness, sharpen);

  n_taps = scale1d_get_n_taps (src->height, dest->height, a, sharpness);
  scale1d_calculate_taps_float (&scale->y_scale1d,
      src->height, dest->height, n_taps, a, sharpness, sharpen);

  scale->dither = dither;

  scale->horiz_resample_func =
      (HorizResampleFunc) resample_horiz_float_u8_generic;

  scale->tmpdata =
      g_malloc (sizeof (float) * scale->dest->width * scale->src->height);

  vs_scale_lanczos_Y_float (scale);

  scale1d_cleanup (&scale->x_scale1d);
  scale1d_cleanup (&scale->y_scale1d);
  g_free (scale->tmpdata);
}





static void
vs_scale_lanczos_AYUV_int16 (Scale * scale)
{
  int j;
  int yi;
  int tmp_yi;

  tmp_yi = 0;

  for (j = 0; j < scale->dest->height; j++) {
    guint8 *destline;
    gint16 *taps;

    destline = scale->dest->pixels + scale->dest->stride * j;

    yi = scale->y_scale1d.offsets[j];

    while (tmp_yi < yi + scale->y_scale1d.n_taps) {
      scale->horiz_resample_func (TMP_LINE_S16_AYUV (tmp_yi),
          scale->x_scale1d.offsets, scale->x_scale1d.taps, SRC_LINE (tmp_yi),
          scale->x_scale1d.n_taps, S16_MIDSHIFT, scale->dest->width);
      tmp_yi++;
    }

    taps = (gint16 *) scale->y_scale1d.taps + j * scale->y_scale1d.n_taps;
    if (scale->dither) {
      resample_vert_dither_int16_generic (destline,
          taps, TMP_LINE_S16_AYUV (scale->y_scale1d.offsets[j]),
          sizeof (gint16) * 4 * scale->dest->width,
          scale->y_scale1d.n_taps, S16_POSTSHIFT, scale->dest->width * 4);
    } else {
      resample_vert_int16_generic (destline,
          taps, TMP_LINE_S16_AYUV (scale->y_scale1d.offsets[j]),
          sizeof (gint16) * 4 * scale->dest->width,
          scale->y_scale1d.n_taps, S16_POSTSHIFT, scale->dest->width * 4);
    }
  }
}

void
vs_image_scale_lanczos_AYUV_int16 (const VSImage * dest, const VSImage * src,
    uint8_t * tmpbuf, double sharpness, gboolean dither, double a,
    double sharpen)
{
  Scale s = { 0 };
  Scale *scale = &s;
  int n_taps;

  scale->dest = dest;
  scale->src = src;

  n_taps = scale1d_get_n_taps (src->width, dest->width, a, sharpness);
  n_taps = ROUND_UP_4 (n_taps);
  scale1d_calculate_taps_int16 (&scale->x_scale1d,
      src->width, dest->width, n_taps, a, sharpness, sharpen, S16_SHIFT1);

  n_taps = scale1d_get_n_taps (src->height, dest->height, a, sharpness);
  scale1d_calculate_taps_int16 (&scale->y_scale1d,
      src->height, dest->height, n_taps, a, sharpness, sharpen, S16_SHIFT2);

  scale->dither = dither;

  switch (scale->x_scale1d.n_taps) {
    case 4:
      scale->horiz_resample_func =
          (HorizResampleFunc) resample_horiz_int16_int16_ayuv_taps4_shift0;
      break;
    case 8:
      scale->horiz_resample_func =
          (HorizResampleFunc) resample_horiz_int16_int16_ayuv_taps8_shift0;
      break;
    case 12:
      scale->horiz_resample_func =
          (HorizResampleFunc) resample_horiz_int16_int16_ayuv_taps12_shift0;
      break;
    case 16:
      scale->horiz_resample_func =
          (HorizResampleFunc) resample_horiz_int16_int16_ayuv_taps16_shift0;
      break;
    default:
      scale->horiz_resample_func =
          (HorizResampleFunc) resample_horiz_int16_int16_ayuv_generic;
      break;
  }

  scale->tmpdata =
      g_malloc (sizeof (gint16) * scale->dest->width * scale->src->height * 4);

  vs_scale_lanczos_AYUV_int16 (scale);

  scale1d_cleanup (&scale->x_scale1d);
  scale1d_cleanup (&scale->y_scale1d);
  g_free (scale->tmpdata);
}


static void
vs_scale_lanczos_AYUV_int32 (Scale * scale)
{
  int j;
  int yi;
  int tmp_yi;

  tmp_yi = 0;

  for (j = 0; j < scale->dest->height; j++) {
    guint8 *destline;
    gint32 *taps;

    destline = scale->dest->pixels + scale->dest->stride * j;

    yi = scale->y_scale1d.offsets[j];

    while (tmp_yi < yi + scale->y_scale1d.n_taps) {
      scale->horiz_resample_func (TMP_LINE_S32_AYUV (tmp_yi),
          scale->x_scale1d.offsets, scale->x_scale1d.taps, SRC_LINE (tmp_yi),
          scale->x_scale1d.n_taps, S32_MIDSHIFT, scale->dest->width);
      tmp_yi++;
    }

    taps = (gint32 *) scale->y_scale1d.taps + j * scale->y_scale1d.n_taps;
    if (scale->dither) {
      resample_vert_dither_int32_generic (destline,
          taps, TMP_LINE_S32_AYUV (scale->y_scale1d.offsets[j]),
          sizeof (gint32) * 4 * scale->dest->width, scale->y_scale1d.n_taps,
          S32_POSTSHIFT, scale->dest->width * 4);
    } else {
      resample_vert_int32_generic (destline,
          taps, TMP_LINE_S32_AYUV (scale->y_scale1d.offsets[j]),
          sizeof (gint32) * 4 * scale->dest->width, scale->y_scale1d.n_taps,
          S32_POSTSHIFT, scale->dest->width * 4);
    }
  }
}

void
vs_image_scale_lanczos_AYUV_int32 (const VSImage * dest, const VSImage * src,
    uint8_t * tmpbuf, double sharpness, gboolean dither, double a,
    double sharpen)
{
  Scale s = { 0 };
  Scale *scale = &s;
  int n_taps;

  scale->dest = dest;
  scale->src = src;

  n_taps = scale1d_get_n_taps (src->width, dest->width, a, sharpness);
  n_taps = ROUND_UP_4 (n_taps);
  scale1d_calculate_taps_int32 (&scale->x_scale1d,
      src->width, dest->width, n_taps, a, sharpness, sharpen, S32_SHIFT1);

  n_taps = scale1d_get_n_taps (src->height, dest->height, a, sharpness);
  scale1d_calculate_taps_int32 (&scale->y_scale1d,
      src->height, dest->height, n_taps, a, sharpness, sharpen, S32_SHIFT2);

  scale->dither = dither;

  switch (scale->x_scale1d.n_taps) {
    case 4:
      scale->horiz_resample_func =
          (HorizResampleFunc) resample_horiz_int32_int32_ayuv_taps4_shift0;
      break;
    case 8:
      scale->horiz_resample_func =
          (HorizResampleFunc) resample_horiz_int32_int32_ayuv_taps8_shift0;
      break;
    case 12:
      scale->horiz_resample_func =
          (HorizResampleFunc) resample_horiz_int32_int32_ayuv_taps12_shift0;
      break;
    case 16:
      scale->horiz_resample_func =
          (HorizResampleFunc) resample_horiz_int32_int32_ayuv_taps16_shift0;
      break;
    default:
      scale->horiz_resample_func =
          (HorizResampleFunc) resample_horiz_int32_int32_ayuv_generic;
      break;
  }

  scale->tmpdata =
      g_malloc (sizeof (int32_t) * scale->dest->width * scale->src->height * 4);

  vs_scale_lanczos_AYUV_int32 (scale);

  scale1d_cleanup (&scale->x_scale1d);
  scale1d_cleanup (&scale->y_scale1d);
  g_free (scale->tmpdata);
}

static void
vs_scale_lanczos_AYUV_double (Scale * scale)
{
  int j;
  int yi;
  int tmp_yi;

  tmp_yi = 0;

  for (j = 0; j < scale->dest->height; j++) {
    guint8 *destline;
    double *taps;

    destline = scale->dest->pixels + scale->dest->stride * j;

    yi = scale->y_scale1d.offsets[j];

    while (tmp_yi < yi + scale->y_scale1d.n_taps) {
      scale->horiz_resample_func (TMP_LINE_DOUBLE_AYUV (tmp_yi),
          scale->x_scale1d.offsets, scale->x_scale1d.taps, SRC_LINE (tmp_yi),
          scale->x_scale1d.n_taps, 0, scale->dest->width);
      tmp_yi++;
    }

    taps = (double *) scale->y_scale1d.taps + j * scale->y_scale1d.n_taps;
    if (scale->dither) {
      resample_vert_dither_double_generic (destline,
          taps, TMP_LINE_DOUBLE_AYUV (scale->y_scale1d.offsets[j]),
          sizeof (double) * 4 * scale->dest->width,
          scale->y_scale1d.n_taps, 0, scale->dest->width * 4);
    } else {
      resample_vert_double_generic (destline,
          taps, TMP_LINE_DOUBLE_AYUV (scale->y_scale1d.offsets[j]),
          sizeof (double) * 4 * scale->dest->width,
          scale->y_scale1d.n_taps, 0, scale->dest->width * 4);
    }
  }
}

void
vs_image_scale_lanczos_AYUV_double (const VSImage * dest, const VSImage * src,
    uint8_t * tmpbuf, double sharpness, gboolean dither, double a,
    double sharpen)
{
  Scale s = { 0 };
  Scale *scale = &s;
  int n_taps;

  scale->dest = dest;
  scale->src = src;

  n_taps = scale1d_get_n_taps (src->width, dest->width, a, sharpness);
  scale1d_calculate_taps (&scale->x_scale1d,
      src->width, dest->width, n_taps, a, sharpness, sharpen);

  n_taps = scale1d_get_n_taps (src->height, dest->height, a, sharpness);
  scale1d_calculate_taps (&scale->y_scale1d,
      src->height, dest->height, n_taps, a, sharpness, sharpen);

  scale->dither = dither;

  scale->horiz_resample_func =
      (HorizResampleFunc) resample_horiz_double_ayuv_generic;

  scale->tmpdata =
      g_malloc (sizeof (double) * scale->dest->width * scale->src->height * 4);

  vs_scale_lanczos_AYUV_double (scale);

  scale1d_cleanup (&scale->x_scale1d);
  scale1d_cleanup (&scale->y_scale1d);
  g_free (scale->tmpdata);
}

static void
vs_scale_lanczos_AYUV_float (Scale * scale)
{
  int j;
  int yi;
  int tmp_yi;

  tmp_yi = 0;

  for (j = 0; j < scale->dest->height; j++) {
    guint8 *destline;
    float *taps;

    destline = scale->dest->pixels + scale->dest->stride * j;

    yi = scale->y_scale1d.offsets[j];

    while (tmp_yi < yi + scale->y_scale1d.n_taps) {
      scale->horiz_resample_func (TMP_LINE_FLOAT_AYUV (tmp_yi),
          scale->x_scale1d.offsets, scale->x_scale1d.taps, SRC_LINE (tmp_yi),
          scale->x_scale1d.n_taps, 0, scale->dest->width);
      tmp_yi++;
    }

    taps = (float *) scale->y_scale1d.taps + j * scale->y_scale1d.n_taps;
    if (scale->dither) {
      resample_vert_dither_float_generic (destline,
          taps, TMP_LINE_FLOAT_AYUV (scale->y_scale1d.offsets[j]),
          sizeof (float) * 4 * scale->dest->width, scale->y_scale1d.n_taps, 0,
          scale->dest->width * 4);
    } else {
      resample_vert_float_generic (destline,
          taps, TMP_LINE_FLOAT_AYUV (scale->y_scale1d.offsets[j]),
          sizeof (float) * 4 * scale->dest->width, scale->y_scale1d.n_taps, 0,
          scale->dest->width * 4);
    }
  }
}

void
vs_image_scale_lanczos_AYUV_float (const VSImage * dest, const VSImage * src,
    uint8_t * tmpbuf, double sharpness, gboolean dither, double a,
    double sharpen)
{
  Scale s = { 0 };
  Scale *scale = &s;
  int n_taps;

  scale->dest = dest;
  scale->src = src;

  n_taps = scale1d_get_n_taps (src->width, dest->width, a, sharpness);
  scale1d_calculate_taps_float (&scale->x_scale1d,
      src->width, dest->width, n_taps, a, sharpness, sharpen);

  n_taps = scale1d_get_n_taps (src->height, dest->height, a, sharpness);
  scale1d_calculate_taps_float (&scale->y_scale1d,
      src->height, dest->height, n_taps, a, sharpness, sharpen);

  scale->dither = dither;

  scale->horiz_resample_func =
      (HorizResampleFunc) resample_horiz_float_ayuv_generic;

  scale->tmpdata =
      g_malloc (sizeof (float) * scale->dest->width * scale->src->height * 4);

  vs_scale_lanczos_AYUV_float (scale);

  scale1d_cleanup (&scale->x_scale1d);
  scale1d_cleanup (&scale->y_scale1d);
  g_free (scale->tmpdata);
}

static void
vs_scale_lanczos_AYUV64_double (Scale * scale)
{
  int j;
  int yi;
  int tmp_yi;

  tmp_yi = 0;

  for (j = 0; j < scale->dest->height; j++) {
    guint16 *destline;
    double *taps;

    destline = (guint16 *) (scale->dest->pixels + scale->dest->stride * j);

    yi = scale->y_scale1d.offsets[j];

    while (tmp_yi < yi + scale->y_scale1d.n_taps) {
      scale->horiz_resample_func (TMP_LINE_DOUBLE_AYUV (tmp_yi),
          scale->x_scale1d.offsets, scale->x_scale1d.taps, SRC_LINE (tmp_yi),
          scale->x_scale1d.n_taps, 0, scale->dest->width);
      tmp_yi++;
    }

    taps = (double *) scale->y_scale1d.taps + j * scale->y_scale1d.n_taps;
    if (scale->dither) {
      resample_vert_dither_double_generic_u16 (destline,
          taps, TMP_LINE_DOUBLE_AYUV (scale->y_scale1d.offsets[j]),
          sizeof (double) * 4 * scale->dest->width,
          scale->y_scale1d.n_taps, 0, scale->dest->width * 4);
    } else {
      resample_vert_double_generic_u16 (destline,
          taps, TMP_LINE_DOUBLE_AYUV (scale->y_scale1d.offsets[j]),
          sizeof (double) * 4 * scale->dest->width,
          scale->y_scale1d.n_taps, 0, scale->dest->width * 4);
    }
  }
}

void
vs_image_scale_lanczos_AYUV64_double (const VSImage * dest, const VSImage * src,
    uint8_t * tmpbuf, double sharpness, gboolean dither, double a,
    double sharpen)
{
  Scale s = { 0 };
  Scale *scale = &s;
  int n_taps;

  scale->dest = dest;
  scale->src = src;

  n_taps = scale1d_get_n_taps (src->width, dest->width, a, sharpness);
  scale1d_calculate_taps (&scale->x_scale1d,
      src->width, dest->width, n_taps, a, sharpness, sharpen);

  n_taps = scale1d_get_n_taps (src->height, dest->height, a, sharpness);
  scale1d_calculate_taps (&scale->y_scale1d,
      src->height, dest->height, n_taps, a, sharpness, sharpen);

  scale->dither = dither;

  scale->horiz_resample_func =
      (HorizResampleFunc) resample_horiz_double_ayuv_generic_s16;

  scale->tmpdata =
      g_malloc (sizeof (double) * scale->dest->width * scale->src->height * 4);

  vs_scale_lanczos_AYUV64_double (scale);

  scale1d_cleanup (&scale->x_scale1d);
  scale1d_cleanup (&scale->y_scale1d);
  g_free (scale->tmpdata);
}
