// Copyright 2016 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.

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

//

// MSA variant of alpha filters

//

// Author: Prashant Patil (prashant.patil@imgtec.com)

#include "src/dsp/dsp.h"

#if defined(WEBP_USE_MSA)

#include "src/dsp/msa_macro.h"

#include <assert.h>

static WEBP_INLINE void PredictLineInverse0(const uint8_t* src,

                                            const uint8_t* pred,

                                            uint8_t* dst, int length) {

  v16u8 src0, pred0, dst0;

  assert(length >= 0);

  while (length >= 32) {

    v16u8 src1, pred1, dst1;

    LD_UB2(src, 16, src0, src1);

    LD_UB2(pred, 16, pred0, pred1);

    SUB2(src0, pred0, src1, pred1, dst0, dst1);

    ST_UB2(dst0, dst1, dst, 16);

    src += 32;

    pred += 32;

    dst += 32;

    length -= 32;

  }

  if (length > 0) {

    int i;

    if (length >= 16) {

      src0 = LD_UB(src);

      pred0 = LD_UB(pred);

      dst0 = src0 - pred0;

      ST_UB(dst0, dst);

      src += 16;

      pred += 16;

      dst += 16;

      length -= 16;

    }

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

      dst[i] = src[i] - pred[i];

    }

  }

}

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

// Helpful macro.

#define SANITY_CHECK(in, out)  \

  assert(in != NULL);          \

  assert(out != NULL);         \

  assert(width > 0);           \

  assert(height > 0);          \

  assert(stride >= width);

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

// Horrizontal filter

static void HorizontalFilter_MSA(const uint8_t* data, int width, int height,

                                 int stride, uint8_t* filtered_data) {

  const uint8_t* preds = data;

  const uint8_t* in = data;

  uint8_t* out = filtered_data;

  int row = 1;

  SANITY_CHECK(in, out);

  // Leftmost pixel is the same as input for topmost scanline.

  out[0] = in[0];

  PredictLineInverse0(in + 1, preds, out + 1, width - 1);

  preds += stride;

  in += stride;

  out += stride;

  // Filter line-by-line.

  while (row < height) {

    // Leftmost pixel is predicted from above.

    PredictLineInverse0(in, preds - stride, out, 1);

    PredictLineInverse0(in + 1, preds, out + 1, width - 1);

    ++row;

    preds += stride;

    in += stride;

    out += stride;

  }

}

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

// Gradient filter

static WEBP_INLINE void PredictLineGradient(const uint8_t* pinput,

                                            const uint8_t* ppred,

                                            uint8_t* poutput, int stride,

                                            int size) {

  int w;

  const v16i8 zero = { 0 };

  while (size >= 16) {

    v16u8 pred0, dst0;

    v8i16 a0, a1, b0, b1, c0, c1;

    const v16u8 tmp0 = LD_UB(ppred - 1);

    const v16u8 tmp1 = LD_UB(ppred - stride);

    const v16u8 tmp2 = LD_UB(ppred - stride - 1);

    const v16u8 src0 = LD_UB(pinput);

    ILVRL_B2_SH(zero, tmp0, a0, a1);

    ILVRL_B2_SH(zero, tmp1, b0, b1);

    ILVRL_B2_SH(zero, tmp2, c0, c1);

    ADD2(a0, b0, a1, b1, a0, a1);

    SUB2(a0, c0, a1, c1, a0, a1);

    CLIP_SH2_0_255(a0, a1);

    pred0 = (v16u8)__msa_pckev_b((v16i8)a1, (v16i8)a0);

    dst0 = src0 - pred0;

    ST_UB(dst0, poutput);

    ppred += 16;

    pinput += 16;

    poutput += 16;

    size -= 16;

  }

  for (w = 0; w < size; ++w) {

    const int pred = ppred[w - 1] + ppred[w - stride] - ppred[w - stride - 1];

    poutput[w] = pinput[w] - (pred < 0 ? 0 : pred > 255 ? 255 : pred);

  }

}

static void GradientFilter_MSA(const uint8_t* data, int width, int height,

                               int stride, uint8_t* filtered_data) {

  const uint8_t* in = data;

  const uint8_t* preds = data;

  uint8_t* out = filtered_data;

  int row = 1;

  SANITY_CHECK(in, out);

  // left prediction for top scan-line

  out[0] = in[0];

  PredictLineInverse0(in + 1, preds, out + 1, width - 1);

  preds += stride;

  in += stride;

  out += stride;

  // Filter line-by-line.

  while (row < height) {

    out[0] = in[0] - preds[- stride];

    PredictLineGradient(preds + 1, in + 1, out + 1, stride, width - 1);

    ++row;

    preds += stride;

    in += stride;

    out += stride;

  }

}

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

// Vertical filter

static void VerticalFilter_MSA(const uint8_t* data, int width, int height,

                               int stride, uint8_t* filtered_data) {

  const uint8_t* in = data;

  const uint8_t* preds = data;

  uint8_t* out = filtered_data;

  int row = 1;

  SANITY_CHECK(in, out);

  // Very first top-left pixel is copied.

  out[0] = in[0];

  // Rest of top scan-line is left-predicted.

  PredictLineInverse0(in + 1, preds, out + 1, width - 1);

  in += stride;

  out += stride;

  // Filter line-by-line.

  while (row < height) {

    PredictLineInverse0(in, preds, out, width);

    ++row;

    preds += stride;

    in += stride;

    out += stride;

  }

}

#undef SANITY_CHECK

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

// Entry point

extern void VP8FiltersInitMSA(void);

WEBP_TSAN_IGNORE_FUNCTION void VP8FiltersInitMSA(void) {

  WebPFilters[WEBP_FILTER_HORIZONTAL] = HorizontalFilter_MSA;

  WebPFilters[WEBP_FILTER_VERTICAL] = VerticalFilter_MSA;

  WebPFilters[WEBP_FILTER_GRADIENT] = GradientFilter_MSA;

}

#else  // !WEBP_USE_MSA

WEBP_DSP_INIT_STUB(VP8FiltersInitMSA)

#endif  // WEBP_USE_MSA