/*
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
 *
 * This source code is subject to the terms of the BSD 2 Clause License and
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
 * was not distributed with this source code in the LICENSE file, you can
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
 * Media Patent License 1.0 was not distributed with this source code in the
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
 */

#include "av1/common/clpf.h"
#include "./aom_dsp_rtcd.h"
#include "aom/aom_image.h"
#include "aom/aom_integer.h"
#include "av1/common/quant_common.h"

// Calculate the error of a filtered and unfiltered block
void aom_clpf_detect_c(const uint8_t *rec, const uint8_t *org, int rstride,
                       int ostride, int x0, int y0, int width, int height,
                       int *sum0, int *sum1, unsigned int strength, int size,
                       unsigned int dmp) {
  int x, y;
  for (y = y0; y < y0 + size; y++) {
    for (x = x0; x < x0 + size; x++) {
      const int O = org[y * ostride + x];
      const int X = rec[y * rstride + x];
      const int A = rec[AOMMAX(0, y - 2) * rstride + x];
      const int B = rec[AOMMAX(0, y - 1) * rstride + x];
      const int C = rec[y * rstride + AOMMAX(0, x - 2)];
      const int D = rec[y * rstride + AOMMAX(0, x - 1)];
      const int E = rec[y * rstride + AOMMIN(width - 1, x + 1)];
      const int F = rec[y * rstride + AOMMIN(width - 1, x + 2)];
      const int G = rec[AOMMIN(height - 1, y + 1) * rstride + x];
      const int H = rec[AOMMIN(height - 1, y + 2) * rstride + x];
      const int delta =
          av1_clpf_sample(X, A, B, C, D, E, F, G, H, strength, dmp);
      const int Y = X + delta;
      *sum0 += (O - X) * (O - X);
      *sum1 += (O - Y) * (O - Y);
    }
  }
}

void aom_clpf_detect_multi_c(const uint8_t *rec, const uint8_t *org,
                             int rstride, int ostride, int x0, int y0,
                             int width, int height, int *sum, int size,
                             unsigned int dmp) {
  int x, y;

  for (y = y0; y < y0 + size; y++) {
    for (x = x0; x < x0 + size; x++) {
      const int O = org[y * ostride + x];
      const int X = rec[y * rstride + x];
      const int A = rec[AOMMAX(0, y - 2) * rstride + x];
      const int B = rec[AOMMAX(0, y - 1) * rstride + x];
      const int C = rec[y * rstride + AOMMAX(0, x - 2)];
      const int D = rec[y * rstride + AOMMAX(0, x - 1)];
      const int E = rec[y * rstride + AOMMIN(width - 1, x + 1)];
      const int F = rec[y * rstride + AOMMIN(width - 1, x + 2)];
      const int G = rec[AOMMIN(height - 1, y + 1) * rstride + x];
      const int H = rec[AOMMIN(height - 1, y + 2) * rstride + x];
      const int delta1 = av1_clpf_sample(X, A, B, C, D, E, F, G, H, 1, dmp);
      const int delta2 = av1_clpf_sample(X, A, B, C, D, E, F, G, H, 2, dmp);
      const int delta3 = av1_clpf_sample(X, A, B, C, D, E, F, G, H, 4, dmp);
      const int F1 = X + delta1;
      const int F2 = X + delta2;
      const int F3 = X + delta3;
      sum[0] += (O - X) * (O - X);
      sum[1] += (O - F1) * (O - F1);
      sum[2] += (O - F2) * (O - F2);
      sum[3] += (O - F3) * (O - F3);
    }
  }
}

#if CONFIG_AOM_HIGHBITDEPTH
// Identical to aom_clpf_detect_c() apart from "rec" and "org".
void aom_clpf_detect_hbd_c(const uint16_t *rec, const uint16_t *org,
                           int rstride, int ostride, int x0, int y0, int width,
                           int height, int *sum0, int *sum1,
                           unsigned int strength, int size, unsigned int bd,
                           unsigned int dmp) {
  const int shift = bd - 8;
  int x, y;
  for (y = y0; y < y0 + size; y++) {
    for (x = x0; x < x0 + size; x++) {
      const int O = org[y * ostride + x] >> shift;
      const int X = rec[y * rstride + x] >> shift;
      const int A = rec[AOMMAX(0, y - 2) * rstride + x] >> shift;
      const int B = rec[AOMMAX(0, y - 1) * rstride + x] >> shift;
      const int C = rec[y * rstride + AOMMAX(0, x - 2)] >> shift;
      const int D = rec[y * rstride + AOMMAX(0, x - 1)] >> shift;
      const int E = rec[y * rstride + AOMMIN(width - 1, x + 1)] >> shift;
      const int F = rec[y * rstride + AOMMIN(width - 1, x + 2)] >> shift;
      const int G = rec[AOMMIN(height - 1, y + 1) * rstride + x] >> shift;
      const int H = rec[AOMMIN(height - 1, y + 2) * rstride + x] >> shift;
      const int delta = av1_clpf_sample(X, A, B, C, D, E, F, G, H,
                                        strength >> shift, dmp - shift);
      const int Y = X + delta;
      *sum0 += (O - X) * (O - X);
      *sum1 += (O - Y) * (O - Y);
    }
  }
}

// aom_clpf_detect_multi_c() apart from "rec" and "org".
void aom_clpf_detect_multi_hbd_c(const uint16_t *rec, const uint16_t *org,
                                 int rstride, int ostride, int x0, int y0,
                                 int width, int height, int *sum, int size,
                                 unsigned int bd, unsigned int dmp) {
  const int shift = bd - 8;
  int x, y;

  for (y = y0; y < y0 + size; y++) {
    for (x = x0; x < x0 + size; x++) {
      int O = org[y * ostride + x] >> shift;
      int X = rec[y * rstride + x] >> shift;
      const int A = rec[AOMMAX(0, y - 2) * rstride + x] >> shift;
      const int B = rec[AOMMAX(0, y - 1) * rstride + x] >> shift;
      const int C = rec[y * rstride + AOMMAX(0, x - 2)] >> shift;
      const int D = rec[y * rstride + AOMMAX(0, x - 1)] >> shift;
      const int E = rec[y * rstride + AOMMIN(width - 1, x + 1)] >> shift;
      const int F = rec[y * rstride + AOMMIN(width - 1, x + 2)] >> shift;
      const int G = rec[AOMMIN(height - 1, y + 1) * rstride + x] >> shift;
      const int H = rec[AOMMIN(height - 1, y + 2) * rstride + x] >> shift;
      const int delta1 =
          av1_clpf_sample(X, A, B, C, D, E, F, G, H, 1, dmp - shift);
      const int delta2 =
          av1_clpf_sample(X, A, B, C, D, E, F, G, H, 2, dmp - shift);
      const int delta3 =
          av1_clpf_sample(X, A, B, C, D, E, F, G, H, 4, dmp - shift);
      const int F1 = X + delta1;
      const int F2 = X + delta2;
      const int F3 = X + delta3;
      sum[0] += (O - X) * (O - X);
      sum[1] += (O - F1) * (O - F1);
      sum[2] += (O - F2) * (O - F2);
      sum[3] += (O - F3) * (O - F3);
    }
  }
}
#endif

int av1_clpf_decision(int k, int l, const YV12_BUFFER_CONFIG *rec,
                      const YV12_BUFFER_CONFIG *org, const AV1_COMMON *cm,
                      int block_size, int w, int h, unsigned int strength,
                      unsigned int fb_size_log2, int8_t *res, int plane) {
  int m, n, sum0 = 0, sum1 = 0;
  int damping =
      cm->bit_depth - 5 - (plane != AOM_PLANE_Y) + (cm->base_qindex >> 6);

  for (m = 0; m < h; m++) {
    for (n = 0; n < w; n++) {
      int xpos = (l << fb_size_log2) + n * block_size;
      int ypos = (k << fb_size_log2) + m * block_size;
      if (fb_size_log2 == MAX_FB_SIZE_LOG2 ||
          !cm->mi_grid_visible[ypos / MI_SIZE * cm->mi_stride + xpos / MI_SIZE]
               ->mbmi.skip) {
#if CONFIG_AOM_HIGHBITDEPTH
        if (cm->use_highbitdepth) {
          aom_clpf_detect_hbd(CONVERT_TO_SHORTPTR(rec->y_buffer),
                              CONVERT_TO_SHORTPTR(org->y_buffer), rec->y_stride,
                              org->y_stride, xpos, ypos, rec->y_crop_width,
                              rec->y_crop_height, &sum0, &sum1, strength,
                              block_size, cm->bit_depth, damping);
        } else {
          aom_clpf_detect(rec->y_buffer, org->y_buffer, rec->y_stride,
                          org->y_stride, xpos, ypos, rec->y_crop_width,
                          rec->y_crop_height, &sum0, &sum1, strength,
                          block_size, damping);
        }
#else
        aom_clpf_detect(rec->y_buffer, org->y_buffer, rec->y_stride,
                        org->y_stride, xpos, ypos, rec->y_crop_width,
                        rec->y_crop_height, &sum0, &sum1, strength, block_size,
                        damping);
#endif
      }
    }
  }
  *res = sum1 < sum0;
  return *res;
}

// Calculate the square error of all filter settings.  Result:
// res[0][0]   : unfiltered
// res[0][1-3] : strength=1,2,4, no signals
// (Only for luma:)
// res[1][0]   : (bit count, fb size = 128)
// res[1][1-3] : strength=1,2,4, fb size = 128
// res[1][4]   : unfiltered, including skip
// res[1][5-7] : strength=1,2,4, including skip, fb_size = 128
// res[2][0]   : (bit count, fb size = 64)
// res[2][1-3] : strength=1,2,4, fb size = 64
// res[3][0]   : (bit count, fb size = 32)
// res[3][1-3] : strength=1,2,4, fb size = 32
static int clpf_rdo(int y, int x, const YV12_BUFFER_CONFIG *rec,
                    const YV12_BUFFER_CONFIG *org, const AV1_COMMON *cm,
                    unsigned int block_size, unsigned int fb_size_log2, int w,
                    int h, int64_t res[4][8], int plane) {
  int c, m, n, filtered = 0;
  int sum[8];
  const int subx = plane != AOM_PLANE_Y && rec->subsampling_x;
  const int suby = plane != AOM_PLANE_Y && rec->subsampling_y;
  int bslog = get_msb(block_size);
  uint8_t *rec_buffer =
      plane != AOM_PLANE_Y
          ? (plane == AOM_PLANE_U ? rec->u_buffer : rec->v_buffer)
          : rec->y_buffer;
  uint8_t *org_buffer =
      plane != AOM_PLANE_Y
          ? (plane == AOM_PLANE_U ? org->u_buffer : org->v_buffer)
          : org->y_buffer;
  int rec_width = plane != AOM_PLANE_Y ? rec->uv_crop_width : rec->y_crop_width;
  int rec_height =
      plane != AOM_PLANE_Y ? rec->uv_crop_height : rec->y_crop_height;
  int rec_stride = plane != AOM_PLANE_Y ? rec->uv_stride : rec->y_stride;
  int org_stride = plane != AOM_PLANE_Y ? org->uv_stride : org->y_stride;
  int damping =
      cm->bit_depth - 5 - (plane != AOM_PLANE_Y) + (cm->base_qindex >> 6);

  sum[0] = sum[1] = sum[2] = sum[3] = sum[4] = sum[5] = sum[6] = sum[7] = 0;
  if (plane == AOM_PLANE_Y &&
      fb_size_log2 > (unsigned int)get_msb(MAX_FB_SIZE) - 3) {
    int w1, h1, w2, h2, i, sum1, sum2, sum3, oldfiltered;

    filtered = fb_size_log2-- == MAX_FB_SIZE_LOG2;
    w1 = AOMMIN(1 << (fb_size_log2 - bslog), w);
    h1 = AOMMIN(1 << (fb_size_log2 - bslog), h);
    w2 = AOMMIN(w - (1 << (fb_size_log2 - bslog)), w >> 1);
    h2 = AOMMIN(h - (1 << (fb_size_log2 - bslog)), h >> 1);
    i = get_msb(MAX_FB_SIZE) - fb_size_log2;
    sum1 = (int)res[i][1];
    sum2 = (int)res[i][2];
    sum3 = (int)res[i][3];
    oldfiltered = (int)res[i][0];
    res[i][0] = 0;

    filtered |= clpf_rdo(y, x, rec, org, cm, block_size, fb_size_log2, w1, h1,
                         res, plane);
    if (1 << (fb_size_log2 - bslog) < w)
      filtered |= clpf_rdo(y, x + (1 << fb_size_log2), rec, org, cm, block_size,
                           fb_size_log2, w2, h1, res, plane);
    if (1 << (fb_size_log2 - bslog) < h) {
      filtered |= clpf_rdo(y + (1 << fb_size_log2), x, rec, org, cm, block_size,
                           fb_size_log2, w1, h2, res, plane);
      filtered |=
          clpf_rdo(y + (1 << fb_size_log2), x + (1 << fb_size_log2), rec, org,
                   cm, block_size, fb_size_log2, w2, h2, res, plane);
    }

    // Correct sums for unfiltered blocks
    res[i][1] = AOMMIN(sum1 + res[i][0], res[i][1]);
    res[i][2] = AOMMIN(sum2 + res[i][0], res[i][2]);
    res[i][3] = AOMMIN(sum3 + res[i][0], res[i][3]);
    if (i == 1) {
      res[i][5] = AOMMIN(sum1 + res[i][4], res[i][5]);
      res[i][6] = AOMMIN(sum2 + res[i][4], res[i][6]);
      res[i][7] = AOMMIN(sum3 + res[i][4], res[i][7]);
    }

    res[i][0] = oldfiltered + filtered;  // Number of signal bits

    return filtered;
  }

  for (m = 0; m < h; m++) {
    for (n = 0; n < w; n++) {
      int xpos = x + n * block_size;
      int ypos = y + m * block_size;
      int skip =  // Filtered skip blocks stored only for fb_size == 128
          4 *
          !!cm->mi_grid_visible[(ypos << suby) / MI_SIZE * cm->mi_stride +
                                (xpos << subx) / MI_SIZE]
                ->mbmi.skip;
#if CONFIG_AOM_HIGHBITDEPTH
      if (cm->use_highbitdepth) {
        aom_clpf_detect_multi_hbd(
            CONVERT_TO_SHORTPTR(rec_buffer), CONVERT_TO_SHORTPTR(org_buffer),
            rec_stride, org_stride, xpos, ypos, rec_width, rec_height,
            sum + skip, block_size, cm->bit_depth, damping);
      } else {
        aom_clpf_detect_multi(rec_buffer, org_buffer, rec_stride, org_stride,
                              xpos, ypos, rec_width, rec_height, sum + skip,
                              block_size, damping);
      }
#else
      aom_clpf_detect_multi(rec_buffer, org_buffer, rec_stride, org_stride,
                            xpos, ypos, rec_width, rec_height, sum + skip,
                            block_size, damping);
#endif
      filtered |= !skip;
    }
  }

  for (c = 0; c < (plane == AOM_PLANE_Y ? 4 : 1); c++) {
    res[c][0] += sum[0];
    res[c][1] += sum[1];
    res[c][2] += sum[2];
    res[c][3] += sum[3];
    if (c != 1) continue;
    // Only needed when fb_size == 128
    res[c][4] += sum[4];
    res[c][5] += sum[5];
    res[c][6] += sum[6];
    res[c][7] += sum[7];
  }
  return filtered;
}

void av1_clpf_test_frame(const YV12_BUFFER_CONFIG *rec,
                         const YV12_BUFFER_CONFIG *org, const AV1_COMMON *cm,
                         int *best_strength, int *best_bs, int plane) {
  int c, j, k, l;
  int64_t best, sums[4][8];
  int width = plane != AOM_PLANE_Y ? rec->uv_crop_width : rec->y_crop_width;
  int height = plane != AOM_PLANE_Y ? rec->uv_crop_height : rec->y_crop_height;
  const int bs = MI_SIZE;
  const int bslog = get_msb(bs);
  int fb_size_log2 = get_msb(MAX_FB_SIZE);
  int num_fb_ver = (height + (1 << fb_size_log2) - bs) >> fb_size_log2;
  int num_fb_hor = (width + (1 << fb_size_log2) - bs) >> fb_size_log2;

  memset(sums, 0, sizeof(sums));

  if (plane != AOM_PLANE_Y)
    // Use a block size of MI_SIZE regardless of the subsampling.  This
    // This is accurate enough to determine the best strength and
    // we don't need to add SIMD optimisations for 4x4 blocks.
    clpf_rdo(0, 0, rec, org, cm, bs, fb_size_log2, width >> bslog,
             height >> bslog, sums, plane);
  else
    for (k = 0; k < num_fb_ver; k++) {
      for (l = 0; l < num_fb_hor; l++) {
        // Calculate the block size after frame border clipping
        int h =
            AOMMIN(height, (k + 1) << fb_size_log2) & ((1 << fb_size_log2) - 1);
        int w =
            AOMMIN(width, (l + 1) << fb_size_log2) & ((1 << fb_size_log2) - 1);
        h += !h << fb_size_log2;
        w += !w << fb_size_log2;
        clpf_rdo(k << fb_size_log2, l << fb_size_log2, rec, org, cm, MI_SIZE,
                 fb_size_log2, w >> bslog, h >> bslog, sums, plane);
      }
    }

  // For fb_size == 128 skip blocks are included in the result.
  if (plane == AOM_PLANE_Y) {
    sums[1][1] += sums[1][5] - sums[1][4];
    sums[1][2] += sums[1][6] - sums[1][4];
    sums[1][3] += sums[1][7] - sums[1][4];
  } else {  // Slightly favour unfiltered chroma
    sums[0][0] -= sums[0][0] >> 7;
  }

  for (j = 0; j < 4; j++) {
    static const double lambda_square[] = {
      // exp(x / 8.5)
      1.0000, 1.1248, 1.2653, 1.4232, 1.6009, 1.8008, 2.0256, 2.2785,
      2.5630, 2.8830, 3.2429, 3.6478, 4.1032, 4.6155, 5.1917, 5.8399,
      6.5689, 7.3891, 8.3116, 9.3492, 10.516, 11.829, 13.306, 14.967,
      16.836, 18.938, 21.302, 23.962, 26.953, 30.318, 34.103, 38.361,
      43.151, 48.538, 54.598, 61.414, 69.082, 77.706, 87.408, 98.320,
      110.59, 124.40, 139.93, 157.40, 177.05, 199.16, 224.02, 251.99,
      283.45, 318.84, 358.65, 403.42, 453.79, 510.45, 574.17, 645.86,
      726.49, 817.19, 919.22, 1033.9, 1163.0, 1308.2, 1471.6, 1655.3
    };

    // Estimate the bit costs and adjust the square errors
    double lambda =
        lambda_square[av1_get_qindex(&cm->seg, 0, cm->base_qindex) >> 2];
    int i, cost = (int)((lambda * (sums[j][0] + 6 + 2 * (j > 0)) + 0.5));
    for (i = 0; i < 4; i++)
      sums[j][i] = ((sums[j][i] + (i && j) * cost) << 4) + j * 4 + i;
  }

  best = (int64_t)1 << 62;
  for (c = 0; c < (plane == AOM_PLANE_Y ? 4 : 1); c++)
    for (j = 0; j < 4; j++)
      if ((!c || j) && sums[c][j] < best) best = sums[c][j];
  best &= 15;
  if (best_bs) *best_bs = (best > 3) * (5 + (best < 12) + (best < 8));
  *best_strength = best ? 1 << ((best - 1) & 3) : 0;
}