/*
 * 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 <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <tuple>
#include <vector>

#include "config/av1_rtcd.h"

#include "aom_ports/aom_timer.h"
#include "av1/common/av1_inv_txfm1d_cfg.h"
#include "av1/common/scan.h"
#include "test/acm_random.h"
#include "test/av1_txfm_test.h"
#include "test/util.h"

using libaom_test::ACMRandom;
using libaom_test::bd;
using libaom_test::compute_avg_abs_error;
using libaom_test::input_base;
using libaom_test::InvTxfm2dFunc;
using libaom_test::LbdInvTxfm2dFunc;

using ::testing::Combine;
using ::testing::Range;
using ::testing::Values;

using std::vector;

typedef TX_TYPE TxType;
typedef TX_SIZE TxSize;

namespace {

static const char *tx_type_name[] = {
  "DCT_DCT",
  "ADST_DCT",
  "DCT_ADST",
  "ADST_ADST",
  "FLIPADST_DCT",
  "DCT_FLIPADST",
  "FLIPADST_FLIPADST",
  "ADST_FLIPADST",
  "FLIPADST_ADST",
  "IDTX",
  "V_DCT",
  "H_DCT",
  "V_ADST",
  "H_ADST",
  "V_FLIPADST",
  "H_FLIPADST",
};

// AV1InvTxfm2dParam argument list:
// tx_type_, tx_size_, max_error_, max_avg_error_
typedef std::tuple<TxType, TxSize, int, double> AV1InvTxfm2dParam;

class AV1InvTxfm2d : public ::testing::TestWithParam<AV1InvTxfm2dParam> {
 public:
  virtual void SetUp() {
    tx_type_ = GET_PARAM(0);
    tx_size_ = GET_PARAM(1);
    max_error_ = GET_PARAM(2);
    max_avg_error_ = GET_PARAM(3);
  }

  void RunRoundtripCheck() {
    int tx_w = tx_size_wide[tx_size_];
    int tx_h = tx_size_high[tx_size_];
    int txfm2d_size = tx_w * tx_h;
    const FwdTxfm2dFunc fwd_txfm_func = libaom_test::fwd_txfm_func_ls[tx_size_];
    const InvTxfm2dFunc inv_txfm_func = libaom_test::inv_txfm_func_ls[tx_size_];
    double avg_abs_error = 0;
    ACMRandom rnd(ACMRandom::DeterministicSeed());

    const int count = 500;

    for (int ci = 0; ci < count; ci++) {
      DECLARE_ALIGNED(16, int16_t, input[64 * 64]) = { 0 };
      ASSERT_LE(txfm2d_size, NELEMENTS(input));

      for (int ni = 0; ni < txfm2d_size; ++ni) {
        if (ci == 0) {
          int extreme_input = input_base - 1;
          input[ni] = extreme_input;  // extreme case
        } else {
          input[ni] = rnd.Rand16() % input_base;
        }
      }

      DECLARE_ALIGNED(16, uint16_t, expected[64 * 64]) = { 0 };
      ASSERT_LE(txfm2d_size, NELEMENTS(expected));
      if (TxfmUsesApproximation()) {
        // Compare reference forward HT + inverse HT vs forward HT + inverse HT.
        double ref_input[64 * 64];
        ASSERT_LE(txfm2d_size, NELEMENTS(ref_input));
        for (int ni = 0; ni < txfm2d_size; ++ni) {
          ref_input[ni] = input[ni];
        }
        double ref_coeffs[64 * 64] = { 0 };
        ASSERT_LE(txfm2d_size, NELEMENTS(ref_coeffs));
        ASSERT_EQ(tx_type_, static_cast<TxType>(DCT_DCT));
        libaom_test::reference_hybrid_2d(ref_input, ref_coeffs, tx_type_,
                                         tx_size_);
        DECLARE_ALIGNED(16, int32_t, ref_coeffs_int[64 * 64]) = { 0 };
        ASSERT_LE(txfm2d_size, NELEMENTS(ref_coeffs_int));
        for (int ni = 0; ni < txfm2d_size; ++ni) {
          ref_coeffs_int[ni] = (int32_t)round(ref_coeffs[ni]);
        }
        inv_txfm_func(ref_coeffs_int, expected, tx_w, tx_type_, bd);
      } else {
        // Compare original input vs forward HT + inverse HT.
        for (int ni = 0; ni < txfm2d_size; ++ni) {
          expected[ni] = input[ni];
        }
      }

      DECLARE_ALIGNED(16, int32_t, coeffs[64 * 64]) = { 0 };
      ASSERT_LE(txfm2d_size, NELEMENTS(coeffs));
      fwd_txfm_func(input, coeffs, tx_w, tx_type_, bd);

      DECLARE_ALIGNED(16, uint16_t, actual[64 * 64]) = { 0 };
      ASSERT_LE(txfm2d_size, NELEMENTS(actual));
      inv_txfm_func(coeffs, actual, tx_w, tx_type_, bd);

      double actual_max_error = 0;
      for (int ni = 0; ni < txfm2d_size; ++ni) {
        const double this_error = abs(expected[ni] - actual[ni]);
        actual_max_error = AOMMAX(actual_max_error, this_error);
      }
      EXPECT_GE(max_error_, actual_max_error)
          << " tx_w: " << tx_w << " tx_h " << tx_h << " tx_type: " << tx_type_;
      if (actual_max_error > max_error_) {  // exit early.
        break;
      }
      avg_abs_error += compute_avg_abs_error<uint16_t, uint16_t>(
          expected, actual, txfm2d_size);
    }

    avg_abs_error /= count;
    EXPECT_GE(max_avg_error_, avg_abs_error)
        << " tx_w: " << tx_w << " tx_h " << tx_h << " tx_type: " << tx_type_;
  }

 private:
  bool TxfmUsesApproximation() {
    if (tx_size_wide[tx_size_] == 64 || tx_size_high[tx_size_] == 64) {
      return true;
    }
    return false;
  }

  int max_error_;
  double max_avg_error_;
  TxType tx_type_;
  TxSize tx_size_;
};

static int max_error_ls[TX_SIZES_ALL] = {
  2,  // 4x4 transform
  2,  // 8x8 transform
  2,  // 16x16 transform
  4,  // 32x32 transform
  3,  // 64x64 transform
  2,  // 4x8 transform
  2,  // 8x4 transform
  2,  // 8x16 transform
  2,  // 16x8 transform
  3,  // 16x32 transform
  3,  // 32x16 transform
  5,  // 32x64 transform
  5,  // 64x32 transform
  2,  // 4x16 transform
  2,  // 16x4 transform
  2,  // 8x32 transform
  2,  // 32x8 transform
  3,  // 16x64 transform
  3,  // 64x16 transform
};

static double avg_error_ls[TX_SIZES_ALL] = {
  0.002,  // 4x4 transform
  0.05,   // 8x8 transform
  0.07,   // 16x16 transform
  0.4,    // 32x32 transform
  0.3,    // 64x64 transform
  0.02,   // 4x8 transform
  0.02,   // 8x4 transform
  0.04,   // 8x16 transform
  0.07,   // 16x8 transform
  0.4,    // 16x32 transform
  0.5,    // 32x16 transform
  0.38,   // 32x64 transform
  0.39,   // 64x32 transform
  0.2,    // 4x16 transform
  0.2,    // 16x4 transform
  0.2,    // 8x32 transform
  0.2,    // 32x8 transform
  0.38,   // 16x64 transform
  0.38,   // 64x16 transform
};

vector<AV1InvTxfm2dParam> GetInvTxfm2dParamList() {
  vector<AV1InvTxfm2dParam> param_list;
  for (int s = 0; s < TX_SIZES; ++s) {
    const int max_error = max_error_ls[s];
    const double avg_error = avg_error_ls[s];
    for (int t = 0; t < TX_TYPES; ++t) {
      const TxType tx_type = static_cast<TxType>(t);
      const TxSize tx_size = static_cast<TxSize>(s);
      if (libaom_test::IsTxSizeTypeValid(tx_size, tx_type)) {
        param_list.push_back(
            AV1InvTxfm2dParam(tx_type, tx_size, max_error, avg_error));
      }
    }
  }
  return param_list;
}

INSTANTIATE_TEST_CASE_P(C, AV1InvTxfm2d,
                        ::testing::ValuesIn(GetInvTxfm2dParamList()));

TEST_P(AV1InvTxfm2d, RunRoundtripCheck) { RunRoundtripCheck(); }

TEST(AV1InvTxfm2d, CfgTest) {
  for (int bd_idx = 0; bd_idx < BD_NUM; ++bd_idx) {
    int bd = libaom_test::bd_arr[bd_idx];
    int8_t low_range = libaom_test::low_range_arr[bd_idx];
    int8_t high_range = libaom_test::high_range_arr[bd_idx];
    for (int tx_size = 0; tx_size < TX_SIZES_ALL; ++tx_size) {
      for (int tx_type = 0; tx_type < TX_TYPES; ++tx_type) {
        if (libaom_test::IsTxSizeTypeValid(static_cast<TxSize>(tx_size),
                                           static_cast<TxType>(tx_type)) ==
            false) {
          continue;
        }
        TXFM_2D_FLIP_CFG cfg;
        av1_get_inv_txfm_cfg(static_cast<TxType>(tx_type),
                             static_cast<TxSize>(tx_size), &cfg);
        int8_t stage_range_col[MAX_TXFM_STAGE_NUM];
        int8_t stage_range_row[MAX_TXFM_STAGE_NUM];
        av1_gen_inv_stage_range(stage_range_col, stage_range_row, &cfg,
                                static_cast<TxSize>(tx_size), bd);
        libaom_test::txfm_stage_range_check(stage_range_col, cfg.stage_num_col,
                                            cfg.cos_bit_col, low_range,
                                            high_range);
        libaom_test::txfm_stage_range_check(stage_range_row, cfg.stage_num_row,
                                            cfg.cos_bit_row, low_range,
                                            high_range);
      }
    }
  }
}

typedef std::tuple<const LbdInvTxfm2dFunc> AV1LbdInvTxfm2dParam;
class AV1LbdInvTxfm2d : public ::testing::TestWithParam<AV1LbdInvTxfm2dParam> {
 public:
  virtual void SetUp() { target_func_ = GET_PARAM(0); }
  void RunAV1InvTxfm2dTest(TxType tx_type, TxSize tx_size, int run_times,
                           int gt_int16 = 0);

 private:
  LbdInvTxfm2dFunc target_func_;
};

void AV1LbdInvTxfm2d::RunAV1InvTxfm2dTest(TxType tx_type, TxSize tx_size,
                                          int run_times, int gt_int16) {
  FwdTxfm2dFunc fwd_func_ = libaom_test::fwd_txfm_func_ls[tx_size];
  InvTxfm2dFunc ref_func_ = libaom_test::inv_txfm_func_ls[tx_size];
  if (fwd_func_ == NULL || ref_func_ == NULL || target_func_ == NULL) {
    return;
  }
  const int bd = 8;
  const int BLK_WIDTH = 64;
  const int BLK_SIZE = BLK_WIDTH * BLK_WIDTH;
  DECLARE_ALIGNED(16, int16_t, input[BLK_SIZE]) = { 0 };
  DECLARE_ALIGNED(32, int32_t, inv_input[BLK_SIZE]) = { 0 };
  DECLARE_ALIGNED(16, uint8_t, output[BLK_SIZE]) = { 0 };
  DECLARE_ALIGNED(16, uint16_t, ref_output[BLK_SIZE]) = { 0 };
  int stride = BLK_WIDTH;
  int rows = tx_size_high[tx_size];
  int cols = tx_size_wide[tx_size];
  const int rows_nonezero = AOMMIN(32, rows);
  const int cols_nonezero = AOMMIN(32, cols);
  run_times /= (rows * cols);
  run_times = AOMMAX(1, run_times);
  const SCAN_ORDER *scan_order = get_default_scan(tx_size, tx_type);
  const int16_t *scan = scan_order->scan;
  const int16_t eobmax = rows_nonezero * cols_nonezero;
  ACMRandom rnd(ACMRandom::DeterministicSeed());
  int randTimes = run_times == 1 ? (eobmax + 500) : 1;

  for (int cnt = 0; cnt < randTimes; ++cnt) {
    const int16_t max_in = (1 << (bd)) - 1;
    for (int r = 0; r < BLK_WIDTH; ++r) {
      for (int c = 0; c < BLK_WIDTH; ++c) {
        input[r * cols + c] = (cnt == 0) ? max_in : rnd.Rand8Extremes();
        output[r * stride + c] = (cnt == 0) ? 128 : rnd.Rand8();
        ref_output[r * stride + c] = output[r * stride + c];
      }
    }
    fwd_func_(input, inv_input, stride, tx_type, bd);

    // produce eob input by setting high freq coeffs to zero
    const int eob = AOMMIN(cnt + 1, eobmax);
    for (int i = eob; i < eobmax; i++) {
      inv_input[scan[i]] = 0;
    }
    if (gt_int16) {
      inv_input[scan[eob - 1]] = ((int32_t)INT16_MAX * 100 / 141);
    }
    aom_usec_timer timer;
    aom_usec_timer_start(&timer);
    for (int i = 0; i < run_times; ++i) {
      ref_func_(inv_input, ref_output, stride, tx_type, bd);
    }
    aom_usec_timer_mark(&timer);
    const double time1 = static_cast<double>(aom_usec_timer_elapsed(&timer));
    aom_usec_timer_start(&timer);
    for (int i = 0; i < run_times; ++i) {
      target_func_(inv_input, output, stride, tx_type, tx_size, eob);
    }
    aom_usec_timer_mark(&timer);
    const double time2 = static_cast<double>(aom_usec_timer_elapsed(&timer));
    if (run_times > 10) {
      printf("txfm[%d] %3dx%-3d:%7.2f/%7.2fns", tx_type, cols, rows, time1,
             time2);
      printf("(%3.2f)\n", time1 / time2);
    }
    for (int r = 0; r < rows; ++r) {
      for (int c = 0; c < cols; ++c) {
        uint8_t ref_value = static_cast<uint8_t>(ref_output[r * stride + c]);
        if (ref_value != output[r * stride + c]) {
          printf(" ");
        }
        ASSERT_EQ(ref_value, output[r * stride + c])
            << "[" << r << "," << c << "] " << cnt
            << " tx_size: " << static_cast<int>(tx_size)
            << " tx_type: " << tx_type_name[tx_type] << " eob " << eob;
      }
    }
  }
}

TEST_P(AV1LbdInvTxfm2d, match) {
  for (int j = 0; j < (int)(TX_SIZES_ALL); ++j) {
    for (int i = 0; i < (int)TX_TYPES; ++i) {
      if (libaom_test::IsTxSizeTypeValid(static_cast<TxSize>(j),
                                         static_cast<TxType>(i))) {
        RunAV1InvTxfm2dTest(static_cast<TxType>(i), static_cast<TxSize>(j), 1);
      }
    }
  }
}

TEST_P(AV1LbdInvTxfm2d, gt_int16) {
  static const TxType types[] = { DCT_DCT, ADST_DCT, FLIPADST_DCT, IDTX,
                                  V_DCT,   H_DCT,    H_ADST,       H_FLIPADST };
  for (int j = 0; j < (int)(TX_SIZES_ALL); ++j) {
    const TxSize sz = static_cast<TxSize>(j);
    for (uint8_t i = 0; i < sizeof(types) / sizeof(types[0]); ++i) {
      const TxType tp = types[i];
      if (libaom_test::IsTxSizeTypeValid(sz, tp)) {
        RunAV1InvTxfm2dTest(tp, sz, 1, 1);
      }
    }
  }
}

TEST_P(AV1LbdInvTxfm2d, DISABLED_Speed) {
  for (int j = 1; j < (int)(TX_SIZES_ALL); ++j) {
    for (int i = 0; i < (int)TX_TYPES; ++i) {
      if (libaom_test::IsTxSizeTypeValid(static_cast<TxSize>(j),
                                         static_cast<TxType>(i))) {
        RunAV1InvTxfm2dTest(static_cast<TxType>(i), static_cast<TxSize>(j),
                            10000000);
      }
    }
  }
}

#if HAVE_SSSE3
#if defined(_MSC_VER) || defined(__SSSE3__)
#include "av1/common/x86/av1_inv_txfm_ssse3.h"
INSTANTIATE_TEST_CASE_P(SSSE3, AV1LbdInvTxfm2d,
                        ::testing::Values(av1_lowbd_inv_txfm2d_add_ssse3));
#endif  // _MSC_VER || __SSSE3__
#endif  // HAVE_SSSE3

#if HAVE_AVX2
extern "C" void av1_lowbd_inv_txfm2d_add_avx2(const int32_t *input,
                                              uint8_t *output, int stride,
                                              TxType tx_type, TxSize tx_size,
                                              int eob);

INSTANTIATE_TEST_CASE_P(AVX2, AV1LbdInvTxfm2d,
                        ::testing::Values(av1_lowbd_inv_txfm2d_add_avx2));
#endif  // HAVE_AVX2

// TODO(yunqing): Re-enable this unit test for NEON version after the functions
// are fixed.
#if HAVE_NEON
extern "C" void av1_lowbd_inv_txfm2d_add_neon(const int32_t *input,
                                              uint8_t *output, int stride,
                                              TX_TYPE tx_type, TX_SIZE tx_size,
                                              int eob);

INSTANTIATE_TEST_CASE_P(NEON, AV1LbdInvTxfm2d,
                        ::testing::Values(av1_lowbd_inv_txfm2d_add_neon));
#endif  // HAVE_NEON

}  // namespace