/*
 * Copyright (c) 2024, 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 <memory>
#include <new>

#include "config/av1_rtcd.h"
#include "test/acm_random.h"
#include "test/util.h"
#include "aom_ports/aom_timer.h"
#include "aom_ports/bitops.h"
#include "third_party/googletest/src/googletest/include/gtest/gtest.h"

namespace {

using ::testing::Combine;
using ::testing::Values;
using ::testing::ValuesIn;

using std::make_tuple;
using std::tuple;

const int kIters = 1000;

typedef tuple<int, int> FrameDimension;

// Check that two 8-bit output buffers are identical.
void AssertOutputBufferEq(const uint8_t *p1, const uint8_t *p2, int width,
                          int height) {
  ASSERT_TRUE(p1 != p2) << "Buffers must be at different memory locations";
  for (int j = 0; j < height; ++j) {
    if (memcmp(p1, p2, sizeof(*p1) * width) == 0) {
      p1 += width;
      p2 += width;
      continue;
    }
    for (int i = 0; i < width; ++i) {
      ASSERT_EQ(p1[i], p2[i])
          << width << "x" << height << " Pixel mismatch at (" << i << ", " << j
          << ")";
    }
  }
}

typedef bool (*LowBDResizeFunc)(uint8_t *intbuf, uint8_t *output,
                                int out_stride, int height, int height2,
                                int stride, int start_wd);
// Test parameter list:
//  <tst_fun, dims>
typedef tuple<LowBDResizeFunc, FrameDimension> ResizeTestParams;

class AV1ResizeYTest : public ::testing::TestWithParam<ResizeTestParams> {
 public:
  void SetUp() {
    test_fun_ = GET_PARAM(0);
    frame_dim_ = GET_PARAM(1);
    width_ = std::get<0>(frame_dim_);
    height_ = std::get<1>(frame_dim_);
    const int msb = get_msb(AOMMIN(width_, height_));
    n_levels_ = AOMMAX(msb - MIN_PYRAMID_SIZE_LOG2, 1);
    const int src_buf_size = (width_ / 2) * height_;
    const int dest_buf_size = (width_ * height_) / 4;
    src_ = std::unique_ptr<uint8_t[]>(new (std::nothrow) uint8_t[src_buf_size]);
    ASSERT_NE(src_, nullptr);

    ref_dest_ =
        std::unique_ptr<uint8_t[]>(new (std::nothrow) uint8_t[dest_buf_size]);
    ASSERT_NE(ref_dest_, nullptr);

    test_dest_ =
        std::unique_ptr<uint8_t[]>(new (std::nothrow) uint8_t[dest_buf_size]);
    ASSERT_NE(test_dest_, nullptr);
  }

  void RunTest() {
    for (int i = 0; i < (width_ / 2) * height_; i++) src_[i] = rng_.Rand8();
    for (int level = 1; level < n_levels_; level++) {
      const int width2 = (width_ >> level);
      const int height2 = (height_ >> level);
      av1_resize_vert_dir_c(src_.get(), ref_dest_.get(), width2, height2 << 1,
                            height2, width2, 0);
      test_fun_(src_.get(), test_dest_.get(), width2, height2 << 1, height2,
                width2, 0);

      AssertOutputBufferEq(ref_dest_.get(), test_dest_.get(), width2, height2);
    }
  }

  void SpeedTest() {
    for (int i = 0; i < (width_ / 2) * height_; i++) src_[i] = rng_.Rand8();
    for (int level = 1; level < n_levels_; level++) {
      const int width2 = (width_ >> level);
      const int height2 = (height_ >> level);
      aom_usec_timer ref_timer;
      aom_usec_timer_start(&ref_timer);
      for (int j = 0; j < kIters; j++) {
        av1_resize_vert_dir_c(src_.get(), ref_dest_.get(), width2, height2 << 1,
                              height2, width2, 0);
      }
      aom_usec_timer_mark(&ref_timer);
      const int64_t ref_time = aom_usec_timer_elapsed(&ref_timer);

      aom_usec_timer tst_timer;
      aom_usec_timer_start(&tst_timer);
      for (int j = 0; j < kIters; j++) {
        test_fun_(src_.get(), test_dest_.get(), width2, height2 << 1, height2,
                  width2, 0);
      }
      aom_usec_timer_mark(&tst_timer);
      const int64_t tst_time = aom_usec_timer_elapsed(&tst_timer);

      std::cout << "level: " << level << " [" << width2 << " x " << height2
                << "] C time = " << ref_time << " , SIMD time = " << tst_time
                << " scaling=" << float(1.00) * ref_time / tst_time << "x \n";
    }
  }

 private:
  LowBDResizeFunc test_fun_;
  FrameDimension frame_dim_;
  int width_;
  int height_;
  int n_levels_;
  std::unique_ptr<uint8_t[]> src_;
  std::unique_ptr<uint8_t[]> ref_dest_;
  std::unique_ptr<uint8_t[]> test_dest_;
  libaom_test::ACMRandom rng_;
};

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(AV1ResizeYTest);

TEST_P(AV1ResizeYTest, RunTest) { RunTest(); }

TEST_P(AV1ResizeYTest, DISABLED_SpeedTest) { SpeedTest(); }

#if HAVE_AVX2 || HAVE_SSE2
// Resolutions (width x height) to be tested for resizing.
const FrameDimension kFrameDim[] = {
  make_tuple(3840, 2160), make_tuple(2560, 1440), make_tuple(1920, 1080),
  make_tuple(1280, 720),  make_tuple(640, 480),   make_tuple(640, 360),
  make_tuple(286, 286),   make_tuple(284, 284),   make_tuple(282, 282),
  make_tuple(280, 280),   make_tuple(262, 262),   make_tuple(258, 258),
  make_tuple(256, 256),   make_tuple(34, 34),
};
#endif

#if HAVE_AVX2
INSTANTIATE_TEST_SUITE_P(
    AVX2, AV1ResizeYTest,
    ::testing::Combine(::testing::Values(av1_resize_vert_dir_avx2),
                       ::testing::ValuesIn(kFrameDim)));
#endif

#if HAVE_SSE2
INSTANTIATE_TEST_SUITE_P(
    SSE2, AV1ResizeYTest,
    ::testing::Combine(::testing::Values(av1_resize_vert_dir_sse2),
                       ::testing::ValuesIn(kFrameDim)));
#endif

typedef void (*LowBDResize_x_Func)(const uint8_t *const input, int in_stride,
                                   uint8_t *intbuf, int height,
                                   int filteredlength, int width2);

typedef tuple<LowBDResize_x_Func, FrameDimension> Resize_x_TestParams;

class AV1ResizeXTest : public ::testing::TestWithParam<Resize_x_TestParams> {
 public:
  void SetUp() {
    test_fun_ = GET_PARAM(0);
    frame_dim_ = GET_PARAM(1);
    width_ = std::get<0>(frame_dim_);
    height_ = std::get<1>(frame_dim_);
    const int msb = get_msb(AOMMIN(width_, height_));
    n_levels_ = AOMMAX(msb - MIN_PYRAMID_SIZE_LOG2, 1);
    const int src_buf_size = width_ * height_;
    const int dest_buf_size = (width_ * height_) / 2;
    src_ = std::unique_ptr<uint8_t[]>(new (std::nothrow) uint8_t[src_buf_size]);
    ASSERT_NE(src_, nullptr);

    ref_dest_ =
        std::unique_ptr<uint8_t[]>(new (std::nothrow) uint8_t[dest_buf_size]);
    ASSERT_NE(ref_dest_, nullptr);

    test_dest_ =
        std::unique_ptr<uint8_t[]>(new (std::nothrow) uint8_t[dest_buf_size]);
    ASSERT_NE(test_dest_, nullptr);
  }

  void RunTest() {
    for (int i = 0; i < width_ * height_; ++i) src_[i] = rng_.Rand8();

    for (int level = 1; level < n_levels_; ++level) {
      const int width2 = (width_ >> level);
      av1_resize_horz_dir_c(src_.get(), width_, ref_dest_.get(), height_,
                            width2 << 1, width2);
      test_fun_(src_.get(), width_, test_dest_.get(), height_, width2 << 1,
                width2);
      AssertOutputBufferEq(ref_dest_.get(), test_dest_.get(), width2, height_);
    }
  }

  void SpeedTest() {
    for (int i = 0; i < width_ * height_; ++i) src_[i] = rng_.Rand8();

    for (int level = 1; level < n_levels_; ++level) {
      const int width2 = (width_ >> level);
      aom_usec_timer ref_timer;
      aom_usec_timer_start(&ref_timer);
      for (int j = 0; j < kIters; ++j) {
        av1_resize_horz_dir_c(src_.get(), width_, ref_dest_.get(), height_,
                              width2 << 1, width2);
      }
      aom_usec_timer_mark(&ref_timer);
      const int64_t ref_time = aom_usec_timer_elapsed(&ref_timer);

      aom_usec_timer tst_timer;
      aom_usec_timer_start(&tst_timer);
      for (int j = 0; j < kIters; ++j) {
        test_fun_(src_.get(), width_, test_dest_.get(), height_, width2 << 1,
                  width2);
      }
      aom_usec_timer_mark(&tst_timer);
      const int64_t tst_time = aom_usec_timer_elapsed(&tst_timer);

      std::cout << "level: " << level << " [" << width2 << " x " << height_
                << "] C time = " << ref_time << " , SIMD time = " << tst_time
                << " scaling=" << float(1.00) * ref_time / tst_time << "x \n";
    }
  }

 private:
  LowBDResize_x_Func test_fun_;
  FrameDimension frame_dim_;
  int width_;
  int height_;
  int n_levels_;
  std::unique_ptr<uint8_t[]> src_;
  std::unique_ptr<uint8_t[]> ref_dest_;
  std::unique_ptr<uint8_t[]> test_dest_;
  libaom_test::ACMRandom rng_;
};

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(AV1ResizeXTest);

TEST_P(AV1ResizeXTest, RunTest) { RunTest(); }

TEST_P(AV1ResizeXTest, DISABLED_SpeedTest) { SpeedTest(); }

#if HAVE_SSE2
INSTANTIATE_TEST_SUITE_P(
    SSE2, AV1ResizeXTest,
    ::testing::Combine(::testing::Values(av1_resize_horz_dir_sse2),
                       ::testing::ValuesIn(kFrameDim)));
#endif

#if HAVE_AVX2
INSTANTIATE_TEST_SUITE_P(
    AVX2, AV1ResizeXTest,
    ::testing::Combine(::testing::Values(av1_resize_horz_dir_avx2),
                       ::testing::ValuesIn(kFrameDim)));
#endif

}  // namespace