diff options
author | trav90 <travawine@palemoon.org> | 2018-10-15 21:45:30 -0500 |
---|---|---|
committer | trav90 <travawine@palemoon.org> | 2018-10-15 21:45:30 -0500 |
commit | 68569dee1416593955c1570d638b3d9250b33012 (patch) | |
tree | d960f017cd7eba3f125b7e8a813789ee2e076310 /third_party/aom/test/selfguided_filter_test.cc | |
parent | 07c17b6b98ed32fcecff15c083ab0fd878de3cf0 (diff) | |
download | UXP-68569dee1416593955c1570d638b3d9250b33012.tar UXP-68569dee1416593955c1570d638b3d9250b33012.tar.gz UXP-68569dee1416593955c1570d638b3d9250b33012.tar.lz UXP-68569dee1416593955c1570d638b3d9250b33012.tar.xz UXP-68569dee1416593955c1570d638b3d9250b33012.zip |
Import aom library
This is the reference implementation for the Alliance for Open Media's av1 video code.
The commit used was 4d668d7feb1f8abd809d1bca0418570a7f142a36.
Diffstat (limited to 'third_party/aom/test/selfguided_filter_test.cc')
-rw-r--r-- | third_party/aom/test/selfguided_filter_test.cc | 274 |
1 files changed, 274 insertions, 0 deletions
diff --git a/third_party/aom/test/selfguided_filter_test.cc b/third_party/aom/test/selfguided_filter_test.cc new file mode 100644 index 000000000..e87fe339a --- /dev/null +++ b/third_party/aom/test/selfguided_filter_test.cc @@ -0,0 +1,274 @@ +/* + * 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 <ctime> + +#include "third_party/googletest/src/googletest/include/gtest/gtest.h" + +#include "./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/mv.h" +#include "av1/common/restoration.h" + +namespace { + +using std::tr1::tuple; +using std::tr1::make_tuple; +using libaom_test::ACMRandom; + +typedef tuple<> FilterTestParam; + +class AV1SelfguidedFilterTest + : public ::testing::TestWithParam<FilterTestParam> { + public: + virtual ~AV1SelfguidedFilterTest() {} + virtual void SetUp() {} + + virtual void TearDown() { libaom_test::ClearSystemState(); } + + protected: + void RunSpeedTest() { + const int w = 256, h = 256; + const int NUM_ITERS = 2000; + int i, j; + + uint8_t *input = (uint8_t *)aom_memalign(16, w * h * sizeof(uint8_t)); + uint8_t *output = (uint8_t *)aom_memalign(16, w * h * sizeof(uint8_t)); + int32_t *tmpbuf = (int32_t *)aom_memalign(16, RESTORATION_TMPBUF_SIZE); + memset(tmpbuf, 0, RESTORATION_TMPBUF_SIZE); + + ACMRandom rnd(ACMRandom::DeterministicSeed()); + + for (i = 0; i < h; ++i) + for (j = 0; j < w; ++j) input[i * w + j] = rnd.Rand16() & 0xFF; + + int xqd[2] = { + SGRPROJ_PRJ_MIN0 + + rnd.PseudoUniform(SGRPROJ_PRJ_MAX0 + 1 - SGRPROJ_PRJ_MIN0), + SGRPROJ_PRJ_MIN1 + + rnd.PseudoUniform(SGRPROJ_PRJ_MAX1 + 1 - SGRPROJ_PRJ_MIN1) + }; + // Fix a parameter set, since the speed depends slightly on r. + // Change this to test different combinations of values of r. + int eps = 15; + + av1_loop_restoration_precal(); + + std::clock_t start = std::clock(); + for (i = 0; i < NUM_ITERS; ++i) { + apply_selfguided_restoration(input, w, h, w, eps, xqd, output, w, tmpbuf); + } + std::clock_t end = std::clock(); + double elapsed = ((end - start) / (double)CLOCKS_PER_SEC); + + printf("%5d %dx%d blocks in %7.3fs = %7.3fus/block\n", NUM_ITERS, w, h, + elapsed, elapsed * 1000000. / NUM_ITERS); + + aom_free(input); + aom_free(output); + aom_free(tmpbuf); + } + + void RunCorrectnessTest() { + // Set the maximum width/height to test here. We actually test a small + // range of sizes *up to* this size, so that we can check, eg., + // the behaviour on tiles which are not a multiple of 4 wide. + const int max_w = 260, max_h = 260, stride = 672, out_stride = 672; + const int NUM_ITERS = 81; + int i, j, k; + + uint8_t *input = + (uint8_t *)aom_memalign(16, stride * max_h * sizeof(uint8_t)); + uint8_t *output = + (uint8_t *)aom_memalign(16, out_stride * max_h * sizeof(uint8_t)); + uint8_t *output2 = + (uint8_t *)aom_memalign(16, out_stride * max_h * sizeof(uint8_t)); + int32_t *tmpbuf = (int32_t *)aom_memalign(16, RESTORATION_TMPBUF_SIZE); + memset(tmpbuf, 0, RESTORATION_TMPBUF_SIZE); + + ACMRandom rnd(ACMRandom::DeterministicSeed()); + + av1_loop_restoration_precal(); + + for (i = 0; i < NUM_ITERS; ++i) { + for (j = 0; j < max_h; ++j) + for (k = 0; k < max_w; ++k) input[j * stride + k] = rnd.Rand16() & 0xFF; + + int xqd[2] = { + SGRPROJ_PRJ_MIN0 + + rnd.PseudoUniform(SGRPROJ_PRJ_MAX0 + 1 - SGRPROJ_PRJ_MIN0), + SGRPROJ_PRJ_MIN1 + + rnd.PseudoUniform(SGRPROJ_PRJ_MAX1 + 1 - SGRPROJ_PRJ_MIN1) + }; + int eps = rnd.PseudoUniform(1 << SGRPROJ_PARAMS_BITS); + + // Test various tile sizes around 256x256 + int test_w = max_w - (i / 9); + int test_h = max_h - (i % 9); + + apply_selfguided_restoration(input, test_w, test_h, stride, eps, xqd, + output, out_stride, tmpbuf); + apply_selfguided_restoration_c(input, test_w, test_h, stride, eps, xqd, + output2, out_stride, tmpbuf); + for (j = 0; j < test_h; ++j) + for (k = 0; k < test_w; ++k) + ASSERT_EQ(output[j * out_stride + k], output2[j * out_stride + k]); + } + + aom_free(input); + aom_free(output); + aom_free(output2); + aom_free(tmpbuf); + } +}; + +TEST_P(AV1SelfguidedFilterTest, SpeedTest) { RunSpeedTest(); } +TEST_P(AV1SelfguidedFilterTest, CorrectnessTest) { RunCorrectnessTest(); } + +const FilterTestParam params[] = { make_tuple() }; + +#if HAVE_SSE4_1 +INSTANTIATE_TEST_CASE_P(SSE4_1, AV1SelfguidedFilterTest, + ::testing::ValuesIn(params)); +#endif + +#if CONFIG_HIGHBITDEPTH + +typedef tuple<int> HighbdFilterTestParam; + +class AV1HighbdSelfguidedFilterTest + : public ::testing::TestWithParam<HighbdFilterTestParam> { + public: + virtual ~AV1HighbdSelfguidedFilterTest() {} + virtual void SetUp() {} + + virtual void TearDown() { libaom_test::ClearSystemState(); } + + protected: + void RunSpeedTest() { + const int w = 256, h = 256; + const int NUM_ITERS = 2000; + int i, j; + int bit_depth = GET_PARAM(0); + int mask = (1 << bit_depth) - 1; + + uint16_t *input = (uint16_t *)aom_memalign(16, w * h * sizeof(uint16_t)); + uint16_t *output = (uint16_t *)aom_memalign(16, w * h * sizeof(uint16_t)); + int32_t *tmpbuf = (int32_t *)aom_memalign(16, RESTORATION_TMPBUF_SIZE); + memset(tmpbuf, 0, RESTORATION_TMPBUF_SIZE); + + ACMRandom rnd(ACMRandom::DeterministicSeed()); + + for (i = 0; i < h; ++i) + for (j = 0; j < w; ++j) input[i * w + j] = rnd.Rand16() & mask; + + int xqd[2] = { + SGRPROJ_PRJ_MIN0 + + rnd.PseudoUniform(SGRPROJ_PRJ_MAX0 + 1 - SGRPROJ_PRJ_MIN0), + SGRPROJ_PRJ_MIN1 + + rnd.PseudoUniform(SGRPROJ_PRJ_MAX1 + 1 - SGRPROJ_PRJ_MIN1) + }; + // Fix a parameter set, since the speed depends slightly on r. + // Change this to test different combinations of values of r. + int eps = 15; + + av1_loop_restoration_precal(); + + std::clock_t start = std::clock(); + for (i = 0; i < NUM_ITERS; ++i) { + apply_selfguided_restoration_highbd(input, w, h, w, bit_depth, eps, xqd, + output, w, tmpbuf); + } + std::clock_t end = std::clock(); + double elapsed = ((end - start) / (double)CLOCKS_PER_SEC); + + printf("%5d %dx%d blocks in %7.3fs = %7.3fus/block\n", NUM_ITERS, w, h, + elapsed, elapsed * 1000000. / NUM_ITERS); + + aom_free(input); + aom_free(output); + aom_free(tmpbuf); + } + + void RunCorrectnessTest() { + // Set the maximum width/height to test here. We actually test a small + // range of sizes *up to* this size, so that we can check, eg., + // the behaviour on tiles which are not a multiple of 4 wide. + const int max_w = 260, max_h = 260, stride = 672, out_stride = 672; + const int NUM_ITERS = 81; + int i, j, k; + int bit_depth = GET_PARAM(0); + int mask = (1 << bit_depth) - 1; + + uint16_t *input = + (uint16_t *)aom_memalign(16, stride * max_h * sizeof(uint16_t)); + uint16_t *output = + (uint16_t *)aom_memalign(16, out_stride * max_h * sizeof(uint16_t)); + uint16_t *output2 = + (uint16_t *)aom_memalign(16, out_stride * max_h * sizeof(uint16_t)); + int32_t *tmpbuf = (int32_t *)aom_memalign(16, RESTORATION_TMPBUF_SIZE); + memset(tmpbuf, 0, RESTORATION_TMPBUF_SIZE); + + ACMRandom rnd(ACMRandom::DeterministicSeed()); + + av1_loop_restoration_precal(); + + for (i = 0; i < NUM_ITERS; ++i) { + for (j = 0; j < max_h; ++j) + for (k = 0; k < max_w; ++k) input[j * stride + k] = rnd.Rand16() & mask; + + int xqd[2] = { + SGRPROJ_PRJ_MIN0 + + rnd.PseudoUniform(SGRPROJ_PRJ_MAX0 + 1 - SGRPROJ_PRJ_MIN0), + SGRPROJ_PRJ_MIN1 + + rnd.PseudoUniform(SGRPROJ_PRJ_MAX1 + 1 - SGRPROJ_PRJ_MIN1) + }; + int eps = rnd.PseudoUniform(1 << SGRPROJ_PARAMS_BITS); + + // Test various tile sizes around 256x256 + int test_w = max_w - (i / 9); + int test_h = max_h - (i % 9); + + apply_selfguided_restoration_highbd(input, test_w, test_h, stride, + bit_depth, eps, xqd, output, + out_stride, tmpbuf); + apply_selfguided_restoration_highbd_c(input, test_w, test_h, stride, + bit_depth, eps, xqd, output2, + out_stride, tmpbuf); + for (j = 0; j < test_h; ++j) + for (k = 0; k < test_w; ++k) + ASSERT_EQ(output[j * out_stride + k], output2[j * out_stride + k]); + } + + aom_free(input); + aom_free(output); + aom_free(output2); + aom_free(tmpbuf); + } +}; + +TEST_P(AV1HighbdSelfguidedFilterTest, SpeedTest) { RunSpeedTest(); } +TEST_P(AV1HighbdSelfguidedFilterTest, CorrectnessTest) { RunCorrectnessTest(); } + +const HighbdFilterTestParam highbd_params[] = { make_tuple(8), make_tuple(10), + make_tuple(12) }; + +#if HAVE_SSE4_1 +INSTANTIATE_TEST_CASE_P(SSE4_1, AV1HighbdSelfguidedFilterTest, + ::testing::ValuesIn(highbd_params)); +#endif +#endif + +} // namespace |