test/av1_fwd_txfm2d_test.cc - aom - Git at Google

 /*
  * 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 "test/acm_random.h"
 #include "test/util.h"
 #include "test/av1_txfm_test.h"
 #include "av1/common/av1_txfm.h"
 #include "./av1_rtcd.h"

 using libaom_test::ACMRandom;
 using libaom_test::input_base;
 using libaom_test::bd;
 using libaom_test::compute_avg_abs_error;
 using libaom_test::Fwd_Txfm2d_Func;
 using libaom_test::TYPE_TXFM;

 namespace {
 #if CONFIG_HIGHBITDEPTH
 // tx_type_, tx_size_, max_error_, max_avg_error_
 typedef std::tr1::tuple<TX_TYPE, TX_SIZE, double, double> AV1FwdTxfm2dParam;

 class AV1FwdTxfm2d : public ::testing::TestWithParam<AV1FwdTxfm2dParam> {
  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);
     count_ = 500;
     TXFM_2D_FLIP_CFG fwd_txfm_flip_cfg =
         av1_get_fwd_txfm_cfg(tx_type_, tx_size_);
     // TODO(sarahparker) this test will need to be updated when these
     // functions are extended to support rectangular transforms
     int amplify_bit = fwd_txfm_flip_cfg.row_cfg->shift[0] +
                       fwd_txfm_flip_cfg.row_cfg->shift[1] +
                       fwd_txfm_flip_cfg.row_cfg->shift[2];
     ud_flip_ = fwd_txfm_flip_cfg.ud_flip;
     lr_flip_ = fwd_txfm_flip_cfg.lr_flip;
     amplify_factor_ =
         amplify_bit >= 0 ? (1 << amplify_bit) : (1.0 / (1 << -amplify_bit));

     fwd_txfm_ = libaom_test::fwd_txfm_func_ls[tx_size_];
     txfm1d_size_ = libaom_test::get_txfm1d_size(tx_size_);
     txfm2d_size_ = txfm1d_size_ * txfm1d_size_;
     get_txfm1d_type(tx_type_, &type0_, &type1_);
     input_ = reinterpret_cast<int16_t *>(
         aom_memalign(16, sizeof(input_[0]) * txfm2d_size_));
     output_ = reinterpret_cast<int32_t *>(
         aom_memalign(16, sizeof(output_[0]) * txfm2d_size_));
     ref_input_ = reinterpret_cast<double *>(
         aom_memalign(16, sizeof(ref_input_[0]) * txfm2d_size_));
     ref_output_ = reinterpret_cast<double *>(
         aom_memalign(16, sizeof(ref_output_[0]) * txfm2d_size_));
   }

   void RunFwdAccuracyCheck() {
     ACMRandom rnd(ACMRandom::DeterministicSeed());
     double avg_abs_error = 0;
     for (int ci = 0; ci < count_; ci++) {
       for (int ni = 0; ni < txfm2d_size_; ++ni) {
         input_[ni] = rnd.Rand16() % input_base;
         ref_input_[ni] = static_cast<double>(input_[ni]);
         output_[ni] = 0;
         ref_output_[ni] = 0;
       }

       fwd_txfm_(input_, output_, txfm1d_size_, tx_type_, bd);

       if (lr_flip_ && ud_flip_)
         libaom_test::fliplrud(ref_input_, txfm1d_size_, txfm1d_size_);
       else if (lr_flip_)
         libaom_test::fliplr(ref_input_, txfm1d_size_, txfm1d_size_);
       else if (ud_flip_)
         libaom_test::flipud(ref_input_, txfm1d_size_, txfm1d_size_);

       reference_hybrid_2d(ref_input_, ref_output_, txfm1d_size_, type0_,
                           type1_);

       for (int ni = 0; ni < txfm2d_size_; ++ni) {
         ref_output_[ni] = round(ref_output_[ni] * amplify_factor_);
         EXPECT_GE(max_error_,
                   fabs(output_[ni] - ref_output_[ni]) / amplify_factor_);
       }
       avg_abs_error += compute_avg_abs_error<int32_t, double>(
           output_, ref_output_, txfm2d_size_);
     }

     avg_abs_error /= amplify_factor_;
     avg_abs_error /= count_;
     // max_abs_avg_error comes from upper bound of avg_abs_error
     // printf("type0: %d type1: %d txfm_size: %d accuracy_avg_abs_error:
     // %f\n", type0_, type1_, txfm1d_size_, avg_abs_error);
     EXPECT_GE(max_avg_error_, avg_abs_error);
   }

   virtual void TearDown() {
     aom_free(input_);
     aom_free(output_);
     aom_free(ref_input_);
     aom_free(ref_output_);
   }

  private:
   double max_error_;
   double max_avg_error_;
   int count_;
   double amplify_factor_;
   TX_TYPE tx_type_;
   TX_SIZE tx_size_;
   int txfm1d_size_;
   int txfm2d_size_;
   Fwd_Txfm2d_Func fwd_txfm_;
   TYPE_TXFM type0_;
   TYPE_TXFM type1_;
   int16_t *input_;
   int32_t *output_;
   double *ref_input_;
   double *ref_output_;
   int ud_flip_;  // flip upside down
   int lr_flip_;  // flip left to right
 };

 TEST_P(AV1FwdTxfm2d, RunFwdAccuracyCheck) { RunFwdAccuracyCheck(); }
 const AV1FwdTxfm2dParam av1_fwd_txfm2d_param_c[] = {
   AV1FwdTxfm2dParam(FLIPADST_DCT, TX_4X4, 2, 0.2),
   AV1FwdTxfm2dParam(DCT_FLIPADST, TX_4X4, 2, 0.2),
   AV1FwdTxfm2dParam(FLIPADST_FLIPADST, TX_4X4, 2, 0.2),
   AV1FwdTxfm2dParam(ADST_FLIPADST, TX_4X4, 2, 0.2),
   AV1FwdTxfm2dParam(FLIPADST_ADST, TX_4X4, 2, 0.2),
   AV1FwdTxfm2dParam(FLIPADST_DCT, TX_8X8, 5, 0.6),
   AV1FwdTxfm2dParam(DCT_FLIPADST, TX_8X8, 5, 0.6),
   AV1FwdTxfm2dParam(FLIPADST_FLIPADST, TX_8X8, 5, 0.6),
   AV1FwdTxfm2dParam(ADST_FLIPADST, TX_8X8, 5, 0.6),
   AV1FwdTxfm2dParam(FLIPADST_ADST, TX_8X8, 5, 0.6),
   AV1FwdTxfm2dParam(FLIPADST_DCT, TX_16X16, 11, 1.5),
   AV1FwdTxfm2dParam(DCT_FLIPADST, TX_16X16, 11, 1.5),
   AV1FwdTxfm2dParam(FLIPADST_FLIPADST, TX_16X16, 11, 1.5),
   AV1FwdTxfm2dParam(ADST_FLIPADST, TX_16X16, 11, 1.5),
   AV1FwdTxfm2dParam(FLIPADST_ADST, TX_16X16, 11, 1.5),
   AV1FwdTxfm2dParam(FLIPADST_DCT, TX_32X32, 70, 7),
   AV1FwdTxfm2dParam(DCT_FLIPADST, TX_32X32, 70, 7),
   AV1FwdTxfm2dParam(FLIPADST_FLIPADST, TX_32X32, 70, 7),
   AV1FwdTxfm2dParam(ADST_FLIPADST, TX_32X32, 70, 7),
   AV1FwdTxfm2dParam(FLIPADST_ADST, TX_32X32, 70, 7),
   AV1FwdTxfm2dParam(DCT_DCT, TX_4X4, 2, 0.2),
   AV1FwdTxfm2dParam(ADST_DCT, TX_4X4, 2, 0.2),
   AV1FwdTxfm2dParam(DCT_ADST, TX_4X4, 2, 0.2),
   AV1FwdTxfm2dParam(ADST_ADST, TX_4X4, 2, 0.2),
   AV1FwdTxfm2dParam(DCT_DCT, TX_8X8, 5, 0.6),
   AV1FwdTxfm2dParam(ADST_DCT, TX_8X8, 5, 0.6),
   AV1FwdTxfm2dParam(DCT_ADST, TX_8X8, 5, 0.6),
   AV1FwdTxfm2dParam(ADST_ADST, TX_8X8, 5, 0.6),
   AV1FwdTxfm2dParam(DCT_DCT, TX_16X16, 11, 1.5),
   AV1FwdTxfm2dParam(ADST_DCT, TX_16X16, 11, 1.5),
   AV1FwdTxfm2dParam(DCT_ADST, TX_16X16, 11, 1.5),
   AV1FwdTxfm2dParam(ADST_ADST, TX_16X16, 11, 1.5),
   AV1FwdTxfm2dParam(DCT_DCT, TX_32X32, 70, 7),
   AV1FwdTxfm2dParam(ADST_DCT, TX_32X32, 70, 7),
   AV1FwdTxfm2dParam(DCT_ADST, TX_32X32, 70, 7),
   AV1FwdTxfm2dParam(ADST_ADST, TX_32X32, 70, 7)
 };

 INSTANTIATE_TEST_CASE_P(C, AV1FwdTxfm2d,
                         ::testing::ValuesIn(av1_fwd_txfm2d_param_c));

 TEST(AV1FwdTxfm2d, 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];
     // TODO(angiebird): include rect txfm in this test
     for (int tx_size = 0; tx_size < TX_SIZES; ++tx_size) {
       for (int tx_type = 0; tx_type < TX_TYPES; ++tx_type) {
         TXFM_2D_FLIP_CFG cfg = av1_get_fwd_txfm_cfg(
             static_cast<TX_TYPE>(tx_type), static_cast<TX_SIZE>(tx_size));
         int8_t stage_range_col[MAX_TXFM_STAGE_NUM];
         int8_t stage_range_row[MAX_TXFM_STAGE_NUM];
         av1_gen_fwd_stage_range(stage_range_col, stage_range_row, &cfg, bd);
         const TXFM_1D_CFG *col_cfg = cfg.col_cfg;
         const TXFM_1D_CFG *row_cfg = cfg.row_cfg;
         libaom_test::txfm_stage_range_check(stage_range_col, col_cfg->stage_num,
                                             col_cfg->cos_bit, low_range,
                                             high_range);
         libaom_test::txfm_stage_range_check(stage_range_row, row_cfg->stage_num,
                                             row_cfg->cos_bit, low_range,
                                             high_range);
       }
     }
   }
 }

 #endif  // CONFIG_HIGHBITDEPTH
 }  // namespace
	/*
	* 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 "test/acm_random.h"
	#include "test/util.h"
	#include "test/av1_txfm_test.h"
	#include "av1/common/av1_txfm.h"
	#include "./av1_rtcd.h"

	using libaom_test::ACMRandom;
	using libaom_test::input_base;
	using libaom_test::bd;
	using libaom_test::compute_avg_abs_error;
	using libaom_test::Fwd_Txfm2d_Func;
	using libaom_test::TYPE_TXFM;

	namespace {
	#if CONFIG_HIGHBITDEPTH
	// tx_type_, tx_size_, max_error_, max_avg_error_
	typedef std::tr1::tuple<TX_TYPE, TX_SIZE, double, double> AV1FwdTxfm2dParam;

	class AV1FwdTxfm2d : public ::testing::TestWithParam<AV1FwdTxfm2dParam> {
	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);
	count_ = 500;
	TXFM_2D_FLIP_CFG fwd_txfm_flip_cfg =
	av1_get_fwd_txfm_cfg(tx_type_, tx_size_);
	// TODO(sarahparker) this test will need to be updated when these
	// functions are extended to support rectangular transforms
	int amplify_bit = fwd_txfm_flip_cfg.row_cfg->shift[0] +
	fwd_txfm_flip_cfg.row_cfg->shift[1] +
	fwd_txfm_flip_cfg.row_cfg->shift[2];
	ud_flip_ = fwd_txfm_flip_cfg.ud_flip;
	lr_flip_ = fwd_txfm_flip_cfg.lr_flip;
	amplify_factor_ =
	amplify_bit >= 0 ? (1 << amplify_bit) : (1.0 / (1 << -amplify_bit));

	fwd_txfm_ = libaom_test::fwd_txfm_func_ls[tx_size_];
	txfm1d_size_ = libaom_test::get_txfm1d_size(tx_size_);
	txfm2d_size_ = txfm1d_size_ * txfm1d_size_;
	get_txfm1d_type(tx_type_, &type0_, &type1_);
	input_ = reinterpret_cast<int16_t *>(
	aom_memalign(16, sizeof(input_[0]) * txfm2d_size_));
	output_ = reinterpret_cast<int32_t *>(
	aom_memalign(16, sizeof(output_[0]) * txfm2d_size_));
	ref_input_ = reinterpret_cast<double *>(
	aom_memalign(16, sizeof(ref_input_[0]) * txfm2d_size_));
	ref_output_ = reinterpret_cast<double *>(
	aom_memalign(16, sizeof(ref_output_[0]) * txfm2d_size_));
	}

	void RunFwdAccuracyCheck() {
	ACMRandom rnd(ACMRandom::DeterministicSeed());
	double avg_abs_error = 0;
	for (int ci = 0; ci < count_; ci++) {
	for (int ni = 0; ni < txfm2d_size_; ++ni) {
	input_[ni] = rnd.Rand16() % input_base;
	ref_input_[ni] = static_cast<double>(input_[ni]);
	output_[ni] = 0;
	ref_output_[ni] = 0;
	}

	fwd_txfm_(input_, output_, txfm1d_size_, tx_type_, bd);

	if (lr_flip_ && ud_flip_)
	libaom_test::fliplrud(ref_input_, txfm1d_size_, txfm1d_size_);
	else if (lr_flip_)
	libaom_test::fliplr(ref_input_, txfm1d_size_, txfm1d_size_);
	else if (ud_flip_)
	libaom_test::flipud(ref_input_, txfm1d_size_, txfm1d_size_);

	reference_hybrid_2d(ref_input_, ref_output_, txfm1d_size_, type0_,
	type1_);

	for (int ni = 0; ni < txfm2d_size_; ++ni) {
	ref_output_[ni] = round(ref_output_[ni] * amplify_factor_);
	EXPECT_GE(max_error_,
	fabs(output_[ni] - ref_output_[ni]) / amplify_factor_);
	}
	avg_abs_error += compute_avg_abs_error<int32_t, double>(
	output_, ref_output_, txfm2d_size_);
	}

	avg_abs_error /= amplify_factor_;
	avg_abs_error /= count_;
	// max_abs_avg_error comes from upper bound of avg_abs_error
	// printf("type0: %d type1: %d txfm_size: %d accuracy_avg_abs_error:
	// %f\n", type0_, type1_, txfm1d_size_, avg_abs_error);
	EXPECT_GE(max_avg_error_, avg_abs_error);
	}

	virtual void TearDown() {
	aom_free(input_);
	aom_free(output_);
	aom_free(ref_input_);
	aom_free(ref_output_);
	}

	private:
	double max_error_;
	double max_avg_error_;
	int count_;
	double amplify_factor_;
	TX_TYPE tx_type_;
	TX_SIZE tx_size_;
	int txfm1d_size_;
	int txfm2d_size_;
	Fwd_Txfm2d_Func fwd_txfm_;
	TYPE_TXFM type0_;
	TYPE_TXFM type1_;
	int16_t *input_;
	int32_t *output_;
	double *ref_input_;
	double *ref_output_;
	int ud_flip_; // flip upside down
	int lr_flip_; // flip left to right
	};

	TEST_P(AV1FwdTxfm2d, RunFwdAccuracyCheck) { RunFwdAccuracyCheck(); }
	const AV1FwdTxfm2dParam av1_fwd_txfm2d_param_c[] = {
	AV1FwdTxfm2dParam(FLIPADST_DCT, TX_4X4, 2, 0.2),
	AV1FwdTxfm2dParam(DCT_FLIPADST, TX_4X4, 2, 0.2),
	AV1FwdTxfm2dParam(FLIPADST_FLIPADST, TX_4X4, 2, 0.2),
	AV1FwdTxfm2dParam(ADST_FLIPADST, TX_4X4, 2, 0.2),
	AV1FwdTxfm2dParam(FLIPADST_ADST, TX_4X4, 2, 0.2),
	AV1FwdTxfm2dParam(FLIPADST_DCT, TX_8X8, 5, 0.6),
	AV1FwdTxfm2dParam(DCT_FLIPADST, TX_8X8, 5, 0.6),
	AV1FwdTxfm2dParam(FLIPADST_FLIPADST, TX_8X8, 5, 0.6),
	AV1FwdTxfm2dParam(ADST_FLIPADST, TX_8X8, 5, 0.6),
	AV1FwdTxfm2dParam(FLIPADST_ADST, TX_8X8, 5, 0.6),
	AV1FwdTxfm2dParam(FLIPADST_DCT, TX_16X16, 11, 1.5),
	AV1FwdTxfm2dParam(DCT_FLIPADST, TX_16X16, 11, 1.5),
	AV1FwdTxfm2dParam(FLIPADST_FLIPADST, TX_16X16, 11, 1.5),
	AV1FwdTxfm2dParam(ADST_FLIPADST, TX_16X16, 11, 1.5),
	AV1FwdTxfm2dParam(FLIPADST_ADST, TX_16X16, 11, 1.5),
	AV1FwdTxfm2dParam(FLIPADST_DCT, TX_32X32, 70, 7),
	AV1FwdTxfm2dParam(DCT_FLIPADST, TX_32X32, 70, 7),
	AV1FwdTxfm2dParam(FLIPADST_FLIPADST, TX_32X32, 70, 7),
	AV1FwdTxfm2dParam(ADST_FLIPADST, TX_32X32, 70, 7),
	AV1FwdTxfm2dParam(FLIPADST_ADST, TX_32X32, 70, 7),
	AV1FwdTxfm2dParam(DCT_DCT, TX_4X4, 2, 0.2),
	AV1FwdTxfm2dParam(ADST_DCT, TX_4X4, 2, 0.2),
	AV1FwdTxfm2dParam(DCT_ADST, TX_4X4, 2, 0.2),
	AV1FwdTxfm2dParam(ADST_ADST, TX_4X4, 2, 0.2),
	AV1FwdTxfm2dParam(DCT_DCT, TX_8X8, 5, 0.6),
	AV1FwdTxfm2dParam(ADST_DCT, TX_8X8, 5, 0.6),
	AV1FwdTxfm2dParam(DCT_ADST, TX_8X8, 5, 0.6),
	AV1FwdTxfm2dParam(ADST_ADST, TX_8X8, 5, 0.6),
	AV1FwdTxfm2dParam(DCT_DCT, TX_16X16, 11, 1.5),
	AV1FwdTxfm2dParam(ADST_DCT, TX_16X16, 11, 1.5),
	AV1FwdTxfm2dParam(DCT_ADST, TX_16X16, 11, 1.5),
	AV1FwdTxfm2dParam(ADST_ADST, TX_16X16, 11, 1.5),
	AV1FwdTxfm2dParam(DCT_DCT, TX_32X32, 70, 7),
	AV1FwdTxfm2dParam(ADST_DCT, TX_32X32, 70, 7),
	AV1FwdTxfm2dParam(DCT_ADST, TX_32X32, 70, 7),
	AV1FwdTxfm2dParam(ADST_ADST, TX_32X32, 70, 7)
	};

	INSTANTIATE_TEST_CASE_P(C, AV1FwdTxfm2d,
	::testing::ValuesIn(av1_fwd_txfm2d_param_c));

	TEST(AV1FwdTxfm2d, 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];
	// TODO(angiebird): include rect txfm in this test
	for (int tx_size = 0; tx_size < TX_SIZES; ++tx_size) {
	for (int tx_type = 0; tx_type < TX_TYPES; ++tx_type) {
	TXFM_2D_FLIP_CFG cfg = av1_get_fwd_txfm_cfg(
	static_cast<TX_TYPE>(tx_type), static_cast<TX_SIZE>(tx_size));
	int8_t stage_range_col[MAX_TXFM_STAGE_NUM];
	int8_t stage_range_row[MAX_TXFM_STAGE_NUM];
	av1_gen_fwd_stage_range(stage_range_col, stage_range_row, &cfg, bd);
	const TXFM_1D_CFG *col_cfg = cfg.col_cfg;
	const TXFM_1D_CFG *row_cfg = cfg.row_cfg;
	libaom_test::txfm_stage_range_check(stage_range_col, col_cfg->stage_num,
	col_cfg->cos_bit, low_range,
	high_range);
	libaom_test::txfm_stage_range_check(stage_range_row, row_cfg->stage_num,
	row_cfg->cos_bit, low_range,
	high_range);
	}
	}
	}
	}

	#endif // CONFIG_HIGHBITDEPTH
	} // namespace