// Copyright 2014 Google Inc. All Rights Reserved.

//

// Use of this source code is governed by a BSD-style license

// that can be found in the COPYING file in the root of the source

// tree. An additional intellectual property rights grant can be found

// in the file PATENTS. All contributing project authors may

// be found in the AUTHORS file in the root of the source tree.

// -----------------------------------------------------------------------------

//

// Rescaling functions

//

// Author: Skal (pascal.massimino@gmail.com)

#include <assert.h>

#include "src/dsp/dsp.h"

#include "src/utils/rescaler_utils.h"

//------------------------------------------------------------------------------

// Implementations of critical functions ImportRow / ExportRow

#define ROUNDER (WEBP_RESCALER_ONE >> 1)

#define MULT_FIX(x, y) (((uint64_t)(x) * (y) + ROUNDER) >> WEBP_RESCALER_RFIX)

//------------------------------------------------------------------------------

// Row import

void WebPRescalerImportRowExpand_C(WebPRescaler* const wrk,

                                   const uint8_t* src) {

  const int x_stride = wrk->num_channels;

  const int x_out_max = wrk->dst_width * wrk->num_channels;

  int channel;

  assert(!WebPRescalerInputDone(wrk));

  assert(wrk->x_expand);

  for (channel = 0; channel < x_stride; ++channel) {

    int x_in = channel;

    int x_out = channel;

    // simple bilinear interpolation

    int accum = wrk->x_add;

    int left = src[x_in];

    int right = (wrk->src_width > 1) ? src[x_in + x_stride] : left;

    x_in += x_stride;

    while (1) {

      wrk->frow[x_out] = right * wrk->x_add + (left - right) * accum;

      x_out += x_stride;

      if (x_out >= x_out_max) break;

      accum -= wrk->x_sub;

      if (accum < 0) {

        left = right;

        x_in += x_stride;

        assert(x_in < wrk->src_width * x_stride);

        right = src[x_in];

        accum += wrk->x_add;

      }

    }

    assert(wrk->x_sub == 0 /* <- special case for src_width=1 */ || accum == 0);

  }

}

void WebPRescalerImportRowShrink_C(WebPRescaler* const wrk,

                                   const uint8_t* src) {

  const int x_stride = wrk->num_channels;

  const int x_out_max = wrk->dst_width * wrk->num_channels;

  int channel;

  assert(!WebPRescalerInputDone(wrk));

  assert(!wrk->x_expand);

  for (channel = 0; channel < x_stride; ++channel) {

    int x_in = channel;

    int x_out = channel;

    uint32_t sum = 0;

    int accum = 0;

    while (x_out < x_out_max) {

      uint32_t base = 0;

      accum += wrk->x_add;

      while (accum > 0) {

        accum -= wrk->x_sub;

        assert(x_in < wrk->src_width * x_stride);

        base = src[x_in];

        sum += base;

        x_in += x_stride;

      }

      {        // Emit next horizontal pixel.

        const rescaler_t frac = base * (-accum);

        wrk->frow[x_out] = sum * wrk->x_sub - frac;

        // fresh fractional start for next pixel

        sum = (int)MULT_FIX(frac, wrk->fx_scale);

      }

      x_out += x_stride;

    }

    assert(accum == 0);

  }

}

//------------------------------------------------------------------------------

// Row export

void WebPRescalerExportRowExpand_C(WebPRescaler* const wrk) {

  int x_out;

  uint8_t* const dst = wrk->dst;

  rescaler_t* const irow = wrk->irow;

  const int x_out_max = wrk->dst_width * wrk->num_channels;

  const rescaler_t* const frow = wrk->frow;

  assert(!WebPRescalerOutputDone(wrk));

  assert(wrk->y_accum <= 0);

  assert(wrk->y_expand);

  assert(wrk->y_sub != 0);

  if (wrk->y_accum == 0) {

    for (x_out = 0; x_out < x_out_max; ++x_out) {

      const uint32_t J = frow[x_out];

      const int v = (int)MULT_FIX(J, wrk->fy_scale);

      assert(v >= 0 && v <= 255);

      dst[x_out] = v;

    }

  } else {

    const uint32_t B = WEBP_RESCALER_FRAC(-wrk->y_accum, wrk->y_sub);

    const uint32_t A = (uint32_t)(WEBP_RESCALER_ONE - B);

    for (x_out = 0; x_out < x_out_max; ++x_out) {

      const uint64_t I = (uint64_t)A * frow[x_out]

                       + (uint64_t)B * irow[x_out];

      const uint32_t J = (uint32_t)((I + ROUNDER) >> WEBP_RESCALER_RFIX);

      const int v = (int)MULT_FIX(J, wrk->fy_scale);

      assert(v >= 0 && v <= 255);

      dst[x_out] = v;

    }

  }

}

void WebPRescalerExportRowShrink_C(WebPRescaler* const wrk) {

  int x_out;

  uint8_t* const dst = wrk->dst;

  rescaler_t* const irow = wrk->irow;

  const int x_out_max = wrk->dst_width * wrk->num_channels;

  const rescaler_t* const frow = wrk->frow;

  const uint32_t yscale = wrk->fy_scale * (-wrk->y_accum);

  assert(!WebPRescalerOutputDone(wrk));

  assert(wrk->y_accum <= 0);

  assert(!wrk->y_expand);

  if (yscale) {

    for (x_out = 0; x_out < x_out_max; ++x_out) {

      const uint32_t frac = (uint32_t)MULT_FIX(frow[x_out], yscale);

      const int v = (int)MULT_FIX(irow[x_out] - frac, wrk->fxy_scale);

      assert(v >= 0 && v <= 255);

      dst[x_out] = v;

      irow[x_out] = frac;   // new fractional start

    }

  } else {

    for (x_out = 0; x_out < x_out_max; ++x_out) {

      const int v = (int)MULT_FIX(irow[x_out], wrk->fxy_scale);

      assert(v >= 0 && v <= 255);

      dst[x_out] = v;

      irow[x_out] = 0;

    }

  }

}

#undef MULT_FIX

#undef ROUNDER

//------------------------------------------------------------------------------

// Main entry calls

void WebPRescalerImportRow(WebPRescaler* const wrk, const uint8_t* src) {

  assert(!WebPRescalerInputDone(wrk));

  if (!wrk->x_expand) {

    WebPRescalerImportRowShrink(wrk, src);

  } else {

    WebPRescalerImportRowExpand(wrk, src);

  }

}

void WebPRescalerExportRow(WebPRescaler* const wrk) {

  if (wrk->y_accum <= 0) {

    assert(!WebPRescalerOutputDone(wrk));

    if (wrk->y_expand) {

      WebPRescalerExportRowExpand(wrk);

    } else if (wrk->fxy_scale) {

      WebPRescalerExportRowShrink(wrk);

    } else {  // special case

      int i;

      assert(wrk->src_height == wrk->dst_height && wrk->x_add == 1);

      assert(wrk->src_width == 1 && wrk->dst_width <= 2);

      for (i = 0; i < wrk->num_channels * wrk->dst_width; ++i) {

        wrk->dst[i] = wrk->irow[i];

        wrk->irow[i] = 0;

      }

    }

    wrk->y_accum += wrk->y_add;

    wrk->dst += wrk->dst_stride;

    ++wrk->dst_y;

  }

}

//------------------------------------------------------------------------------

WebPRescalerImportRowFunc WebPRescalerImportRowExpand;

WebPRescalerImportRowFunc WebPRescalerImportRowShrink;

WebPRescalerExportRowFunc WebPRescalerExportRowExpand;

WebPRescalerExportRowFunc WebPRescalerExportRowShrink;

extern void WebPRescalerDspInitSSE2(void);

extern void WebPRescalerDspInitMIPS32(void);

extern void WebPRescalerDspInitMIPSdspR2(void);

extern void WebPRescalerDspInitMSA(void);

extern void WebPRescalerDspInitNEON(void);

WEBP_DSP_INIT_FUNC(WebPRescalerDspInit) {

#if !defined(WEBP_REDUCE_SIZE)

#if !WEBP_NEON_OMIT_C_CODE

  WebPRescalerExportRowExpand = WebPRescalerExportRowExpand_C;

  WebPRescalerExportRowShrink = WebPRescalerExportRowShrink_C;

#endif

  WebPRescalerImportRowExpand = WebPRescalerImportRowExpand_C;

  WebPRescalerImportRowShrink = WebPRescalerImportRowShrink_C;

  if (VP8GetCPUInfo != NULL) {

#if defined(WEBP_USE_SSE2)

    if (VP8GetCPUInfo(kSSE2)) {

      WebPRescalerDspInitSSE2();

    }

#endif

#if defined(WEBP_USE_MIPS32)

    if (VP8GetCPUInfo(kMIPS32)) {

      WebPRescalerDspInitMIPS32();

    }

#endif

#if defined(WEBP_USE_MIPS_DSP_R2)

    if (VP8GetCPUInfo(kMIPSdspR2)) {

      WebPRescalerDspInitMIPSdspR2();

    }

#endif

#if defined(WEBP_USE_MSA)

    if (VP8GetCPUInfo(kMSA)) {

      WebPRescalerDspInitMSA();

    }

#endif

  }

#if defined(WEBP_USE_NEON)

  if (WEBP_NEON_OMIT_C_CODE ||

      (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kNEON))) {

    WebPRescalerDspInitNEON();

  }

#endif

  assert(WebPRescalerExportRowExpand != NULL);

  assert(WebPRescalerExportRowShrink != NULL);

  assert(WebPRescalerImportRowExpand != NULL);

  assert(WebPRescalerImportRowShrink != NULL);

#endif   // WEBP_REDUCE_SIZE

}