path: root/media/libaom/src/test/error_block_test.cc

/*
 * 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 <cmath>
#include <cstdlib>
#include <string>
#include <tuple>

#include "third_party/googletest/src/googletest/include/gtest/gtest.h"

#include "config/aom_config.h"
#include "config/av1_rtcd.h"

#include "test/acm_random.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "test/util.h"
#include "av1/common/entropy.h"
#include "aom/aom_codec.h"
#include "aom/aom_integer.h"

using libaom_test::ACMRandom;

namespace {
const int kNumIterations = 1000;

typedef int64_t (*ErrorBlockFunc)(const tran_low_t *coeff,
                                  const tran_low_t *dqcoeff,
                                  intptr_t block_size, int64_t *ssz, int bps);

typedef int64_t (*ErrorBlockFunc8Bits)(const tran_low_t *coeff,
                                       const tran_low_t *dqcoeff,
                                       intptr_t block_size, int64_t *ssz);

typedef std::tuple<ErrorBlockFunc, ErrorBlockFunc, aom_bit_depth_t>
    ErrorBlockParam;

template <ErrorBlockFunc8Bits fn>
int64_t BlockError8BitWrapper(const tran_low_t *coeff,
                              const tran_low_t *dqcoeff, intptr_t block_size,
                              int64_t *ssz, int bps) {
  EXPECT_EQ(bps, 8);
  return fn(coeff, dqcoeff, block_size, ssz);
}

class ErrorBlockTest : public ::testing::TestWithParam<ErrorBlockParam> {
 public:
  virtual ~ErrorBlockTest() {}
  virtual void SetUp() {
    error_block_op_ = GET_PARAM(0);
    ref_error_block_op_ = GET_PARAM(1);
    bit_depth_ = GET_PARAM(2);
  }

  virtual void TearDown() { libaom_test::ClearSystemState(); }

 protected:
  aom_bit_depth_t bit_depth_;
  ErrorBlockFunc error_block_op_;
  ErrorBlockFunc ref_error_block_op_;
};

TEST_P(ErrorBlockTest, OperationCheck) {
  ACMRandom rnd(ACMRandom::DeterministicSeed());
  DECLARE_ALIGNED(16, tran_low_t, coeff[4096]);
  DECLARE_ALIGNED(16, tran_low_t, dqcoeff[4096]);
  int err_count_total = 0;
  int first_failure = -1;
  intptr_t block_size;
  int64_t ssz;
  int64_t ret;
  int64_t ref_ssz;
  int64_t ref_ret;
  const int msb = bit_depth_ + 8 - 1;
  for (int i = 0; i < kNumIterations; ++i) {
    int err_count = 0;
    block_size = 16 << (i % 9);  // All block sizes from 4x4, 8x4 ..64x64
    for (int j = 0; j < block_size; j++) {
      // coeff and dqcoeff will always have at least the same sign, and this
      // can be used for optimization, so generate test input precisely.
      if (rnd(2)) {
        // Positive number
        coeff[j] = rnd(1 << msb);
        dqcoeff[j] = rnd(1 << msb);
      } else {
        // Negative number
        coeff[j] = -rnd(1 << msb);
        dqcoeff[j] = -rnd(1 << msb);
      }
    }
    ref_ret =
        ref_error_block_op_(coeff, dqcoeff, block_size, &ref_ssz, bit_depth_);
    ASM_REGISTER_STATE_CHECK(
        ret = error_block_op_(coeff, dqcoeff, block_size, &ssz, bit_depth_));
    err_count += (ref_ret != ret) | (ref_ssz != ssz);
    if (err_count && !err_count_total) {
      first_failure = i;
    }
    err_count_total += err_count;
  }
  EXPECT_EQ(0, err_count_total)
      << "Error: Error Block Test, C output doesn't match optimized output. "
      << "First failed at test case " << first_failure;
}

TEST_P(ErrorBlockTest, ExtremeValues) {
  ACMRandom rnd(ACMRandom::DeterministicSeed());
  DECLARE_ALIGNED(16, tran_low_t, coeff[4096]);
  DECLARE_ALIGNED(16, tran_low_t, dqcoeff[4096]);
  int err_count_total = 0;
  int first_failure = -1;
  intptr_t block_size;
  int64_t ssz;
  int64_t ret;
  int64_t ref_ssz;
  int64_t ref_ret;
  const int msb = bit_depth_ + 8 - 1;
  int max_val = ((1 << msb) - 1);
  for (int i = 0; i < kNumIterations; ++i) {
    int err_count = 0;
    int k = (i / 9) % 9;

    // Change the maximum coeff value, to test different bit boundaries
    if (k == 8 && (i % 9) == 0) {
      max_val >>= 1;
    }
    block_size = 16 << (i % 9);  // All block sizes from 4x4, 8x4 ..64x64
    for (int j = 0; j < block_size; j++) {
      if (k < 4) {
        // Test at positive maximum values
        coeff[j] = k % 2 ? max_val : 0;
        dqcoeff[j] = (k >> 1) % 2 ? max_val : 0;
      } else if (k < 8) {
        // Test at negative maximum values
        coeff[j] = k % 2 ? -max_val : 0;
        dqcoeff[j] = (k >> 1) % 2 ? -max_val : 0;
      } else {
        if (rnd(2)) {
          // Positive number
          coeff[j] = rnd(1 << 14);
          dqcoeff[j] = rnd(1 << 14);
        } else {
          // Negative number
          coeff[j] = -rnd(1 << 14);
          dqcoeff[j] = -rnd(1 << 14);
        }
      }
    }
    ref_ret =
        ref_error_block_op_(coeff, dqcoeff, block_size, &ref_ssz, bit_depth_);
    ASM_REGISTER_STATE_CHECK(
        ret = error_block_op_(coeff, dqcoeff, block_size, &ssz, bit_depth_));
    err_count += (ref_ret != ret) | (ref_ssz != ssz);
    if (err_count && !err_count_total) {
      first_failure = i;
    }
    err_count_total += err_count;
  }
  EXPECT_EQ(0, err_count_total)
      << "Error: Error Block Test, C output doesn't match optimized output. "
      << "First failed at test case " << first_failure;
}

TEST_P(ErrorBlockTest, DISABLED_Speed) {
  ACMRandom rnd(ACMRandom::DeterministicSeed());
  DECLARE_ALIGNED(16, tran_low_t, coeff[4096]);
  DECLARE_ALIGNED(16, tran_low_t, dqcoeff[4096]);
  intptr_t block_size;
  int64_t ssz;
  int num_iters = 100000;
  int64_t ref_ssz;
  int k;
  const int msb = bit_depth_ + 8 - 1;
  for (int i = 0; i < 9; ++i) {
    block_size = 16 << (i % 9);  // All block sizes from 4x4, 8x4 ..64x64
    for (k = 0; k < 9; k++) {
      for (int j = 0; j < block_size; j++) {
        if (k < 5) {
          if (rnd(2)) {
            // Positive number
            coeff[j] = rnd(1 << msb);
            dqcoeff[j] = rnd(1 << msb);
          } else {
            // Negative number
            coeff[j] = -rnd(1 << msb);
            dqcoeff[j] = -rnd(1 << msb);
          }
        } else {
          if (rnd(2)) {
            // Positive number
            coeff[j] = rnd(1 << 14);
            dqcoeff[j] = rnd(1 << 14);
          } else {
            // Negative number
            coeff[j] = -rnd(1 << 14);
            dqcoeff[j] = -rnd(1 << 14);
          }
        }
      }
      aom_usec_timer ref_timer, test_timer;

      aom_usec_timer_start(&ref_timer);
      for (int i = 0; i < num_iters; ++i) {
        ref_error_block_op_(coeff, dqcoeff, block_size, &ref_ssz, bit_depth_);
      }
      aom_usec_timer_mark(&ref_timer);
      const int elapsed_time_c =
          static_cast<int>(aom_usec_timer_elapsed(&ref_timer));

      aom_usec_timer_start(&test_timer);
      for (int i = 0; i < num_iters; ++i) {
        error_block_op_(coeff, dqcoeff, block_size, &ssz, bit_depth_);
      }
      aom_usec_timer_mark(&test_timer);

      const int elapsed_time_simd =
          static_cast<int>(aom_usec_timer_elapsed(&test_timer));

      printf(
          " c_time=%d \t simd_time=%d \t "
          "gain=%d \n",
          elapsed_time_c, elapsed_time_simd,
          (elapsed_time_c / elapsed_time_simd));
    }
  }
}

using std::make_tuple;

#if (HAVE_SSE2)
const ErrorBlockParam kErrorBlockTestParamsSse2[] = {
#if CONFIG_AV1_HIGHBITDEPTH
  make_tuple(&av1_highbd_block_error_sse2, &av1_highbd_block_error_c,
             AOM_BITS_10),
  make_tuple(&av1_highbd_block_error_sse2, &av1_highbd_block_error_c,
             AOM_BITS_12),
  make_tuple(&av1_highbd_block_error_sse2, &av1_highbd_block_error_c,
             AOM_BITS_8),
#endif
  make_tuple(&BlockError8BitWrapper<av1_block_error_sse2>,
             &BlockError8BitWrapper<av1_block_error_c>, AOM_BITS_8)
};

INSTANTIATE_TEST_SUITE_P(SSE2, ErrorBlockTest,
                         ::testing::ValuesIn(kErrorBlockTestParamsSse2));
#endif  // HAVE_SSE2

#if (HAVE_AVX2)
const ErrorBlockParam kErrorBlockTestParamsAvx2[] = {
#if CONFIG_AV1_HIGHBITDEPTH
  make_tuple(&av1_highbd_block_error_avx2, &av1_highbd_block_error_c,
             AOM_BITS_10),
  make_tuple(&av1_highbd_block_error_avx2, &av1_highbd_block_error_c,
             AOM_BITS_12),
  make_tuple(&av1_highbd_block_error_avx2, &av1_highbd_block_error_c,
             AOM_BITS_8),
#endif
  make_tuple(&BlockError8BitWrapper<av1_block_error_avx2>,
             &BlockError8BitWrapper<av1_block_error_c>, AOM_BITS_8)
};

INSTANTIATE_TEST_SUITE_P(AVX2, ErrorBlockTest,
                         ::testing::ValuesIn(kErrorBlockTestParamsAvx2));
#endif  // HAVE_AVX2

#if (HAVE_MSA)
INSTANTIATE_TEST_SUITE_P(
    MSA, ErrorBlockTest,
    ::testing::Values(make_tuple(&BlockError8BitWrapper<av1_block_error_msa>,
                                 &BlockError8BitWrapper<av1_block_error_c>,
                                 AOM_BITS_8)));
#endif  // HAVE_MSA

#if (HAVE_NEON)
INSTANTIATE_TEST_SUITE_P(
    NEON, ErrorBlockTest,
    ::testing::Values(make_tuple(&BlockError8BitWrapper<av1_block_error_neon>,
                                 &BlockError8BitWrapper<av1_block_error_c>,
                                 AOM_BITS_8)));
#endif  // HAVE_NEON
}  // namespace