Commit fb65f9b5 authored by Debargha Mukherjee's avatar Debargha Mukherjee Committed by Gerrit Code Review
Browse files

Merge "Add optimized vpx_blend_mask6" into nextgenv2

parents fa502297 a661bc87
/*
* Copyright (c) 2016 The WebM project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef TEST_ASSERTION_HELPERS_H_
#define TEST_ASSERTION_HELPERS_H_
#include "third_party/googletest/src/include/gtest/gtest.h"
namespace libvpx_test {
namespace assertion_helpers {
// Arrays (1D) are element-wise equal
template<typename E, size_t n>
::testing::AssertionResult ArraysEq(const E (&a)[n],
const E (&b)[n]) {
for (size_t i = 0; i < n; i++) {
const E &va = a[i];
const E &vb = b[i];
if (va != vb) {
return ::testing::AssertionFailure()
<< "Arrays do not equal at index "
<< "[" << i << "]"
<< " values are: " << va << " vs " << vb;
}
}
return ::testing::AssertionSuccess();
}
// Arrays (1D) are element-wise equal
// within the index interval [lo, hi)
template<typename E, size_t n>
::testing::AssertionResult ArraysEqWithin(const E (&a)[n],
const E (&b)[n],
const size_t lo,
const size_t hi) {
assert(hi > lo);
assert(hi <= n);
for (size_t i = lo; i < hi; i++) {
const E &va = a[i];
const E &vb = b[i];
if (va != vb) {
return ::testing::AssertionFailure()
<< "Arrays do not equal at index "
<< "[" << i << "]"
<< " values are: " << va << " vs " << vb;
}
}
return ::testing::AssertionSuccess();
}
// Arrays (1D) are element-wise equal
// outside the index interval [lo, hi)
template<typename E, size_t n>
::testing::AssertionResult ArraysEqOutside(const E (&a)[n],
const E (&b)[n],
const size_t lo,
const size_t hi) {
assert(hi > lo);
assert(hi <= n);
for (size_t i = 0; i < n; i++) {
if (lo <= i && i < hi)
continue;
const E &va = a[i];
const E &vb = b[i];
if (va != vb) {
return ::testing::AssertionFailure()
<< "Arrays do not equal at index "
<< "[" << i << "]"
<< " values are: " << va << " vs " << vb;
}
}
return ::testing::AssertionSuccess();
}
// Arrays (2D) are element-wise equal
template<typename E, size_t n, size_t m>
::testing::AssertionResult ArraysEq(const E (&a)[n][m],
const E (&b)[n][m]) {
for (size_t i = 0; i < n; i++) {
for (size_t j = 0; j < m; j++) {
const E &va = a[i][j];
const E &vb = b[i][j];
if (va != vb) {
return ::testing::AssertionFailure()
<< "Arrays do not equal at index "
<< "[" << i << "][" << j << "]"
<< " values are: " << va << " vs " << vb;
}
}
}
return ::testing::AssertionSuccess();
}
// Arrays (2D) are element-wise equal
// within the index interval [lo0, hi0) x [lo1, hi1) (Cartesian product)
template<typename E, size_t n, size_t m>
::testing::AssertionResult ArraysEqWithin(const E (&a)[n][m],
const E (&b)[n][m],
const size_t lo0,
const size_t hi0,
const size_t lo1,
const size_t hi1) {
assert(hi0 > lo0);
assert(hi0 <= n);
assert(hi1 > lo1);
assert(hi1 <= m);
for (size_t i = lo0; i < hi0; i++) {
for (size_t j = lo1; j < hi1; j++) {
const E &va = a[i][j];
const E &vb = b[i][j];
if (va != vb) {
return ::testing::AssertionFailure()
<< "Arrays do not equal at index "
<< "[" << i << "][" << j << "]"
<< " values are: " << va << " vs " << vb;
}
}
}
return ::testing::AssertionSuccess();
}
// Arrays (2D) are element-wise equal
// outside the index interval [lo0, hi0) x [lo1, hi1) (Cartesian product)
template<typename E, size_t n, size_t m>
::testing::AssertionResult ArraysEqOutside(const E (&a)[n][m],
const E (&b)[n][m],
const size_t lo0,
const size_t hi0,
const size_t lo1,
const size_t hi1) {
assert(hi0 > lo0);
assert(hi0 <= n);
assert(hi1 > lo1);
assert(hi1 <= m);
for (size_t i = 0; i < n; i++) {
if (lo0 <= i && i < hi0)
continue;
for (size_t j = 0; j < m; j++) {
if (lo1 <= j && j < hi1)
continue;
const E &va = a[i][j];
const E &vb = b[i][j];
if (va != vb) {
return ::testing::AssertionFailure()
<< "Arrays do not equal at index "
<< "[" << i << "][" << j << "]"
<< " values are: " << va << " vs " << vb;
}
}
}
return ::testing::AssertionSuccess();
}
// Non contiguous 2D array buffers are element-wise equal
// at corresponding linear indices specified by rows/cols/stride/offset
template<typename E, size_t n, size_t m>
::testing::AssertionResult BuffersEqWithin(const E (&a)[n][m],
const E (&b)[n][m],
const size_t stridea,
const size_t strideb,
const size_t offseta,
const size_t offsetb,
const size_t rows,
const size_t cols) {
assert(rows <= n);
assert(cols <= m);
assert(stridea <= m);
assert(strideb <= m);
assert(cols <= stridea);
assert(cols <= strideb);
assert(offseta < n * m);
assert(offsetb < n * m);
assert(offseta + (rows - 1) * stridea + (cols - 1) < n * m);
assert(offsetb + (rows - 1) * strideb + (cols - 1) < n * m);
const E *pa = &a[0][0] + offseta;
const E *pb = &b[0][0] + offsetb;
for (size_t r = 0 ; r < rows ; r++) {
for (size_t c = 0 ; c < cols ; c++) {
const E &va = pa[c];
const E &vb = pb[c];
if (va != vb) {
return ::testing::AssertionFailure()
<< "Arrays do not equal at linear index "
<< "[" << pa - &a[0][0] << "] vs [" << pb - &b[0][0] << "]"
<< " row=" << r << " col=" << c
<< " values are: " << va << " vs " << vb;
}
}
pa += stridea;
pb += strideb;
}
return ::testing::AssertionSuccess();
}
// Non contiguous 2D array buffers are element-wise equal
// except at corresponding linear indices specified by
// rows/cols/stride/offset.
template<typename E, size_t n, size_t m>
::testing::AssertionResult BuffersEqOutside(const E (&a)[n][m],
const E (&b)[n][m],
const size_t stride,
const size_t offset,
const size_t rows,
const size_t cols ) {
assert(rows <= n);
assert(cols <= m);
assert(stride <= m);
assert(cols <= stride);
assert(offset < n * m);
assert(offset + (rows - 1) * stride + (cols - 1) < n * m);
const E *const pa = &a[0][0];
const E *const pb = &b[0][0];
size_t idx = 0;
size_t r = 0;
size_t end = offset; // beginning of first row
while (idx < n * m) {
while (idx < end) { // until beginning of row or end of buffer
const E &va = pa[idx];
const E &vb = pb[idx];
if (va != vb) {
return ::testing::AssertionFailure()
<< "Arrays do not equal at index "
<< "[" << idx / m << "][" << idx % m << "]"
<< " values are: " << va << " vs " << vb;
}
idx++;
}
// Move past row end
idx += cols;
if (++r < rows) {
// Move to next row
end += stride;
} else {
// Move to end of buffer
end = n * m;
}
}
// Sanity check
assert(idx == n * m + cols);
return ::testing::AssertionSuccess();
}
} // namespace assertion_helpers
} // namespace libvpx_test
#endif // TEST_ASSERTION_HELPERS_H_
/*
* Copyright (c) 2016 The WebM project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include "third_party/googletest/src/include/gtest/gtest.h"
#include "test/register_state_check.h"
#include "test/function_equivalence_test.h"
#include "test/randomise.h"
#include "test/snapshot.h"
#include "./vpx_config.h"
#include "./vpx_dsp_rtcd.h"
#include "vpx/vpx_integer.h"
#include "./vp10_rtcd.h"
#include "test/assertion_helpers.h"
#include "vp10/common/enums.h"
using libvpx_test::assertion_helpers::BuffersEqWithin;
using libvpx_test::assertion_helpers::BuffersEqOutside;
using libvpx_test::assertion_helpers::ArraysEq;
using libvpx_test::FunctionEquivalenceTest;
using libvpx_test::Snapshot;
using libvpx_test::Randomise;
using std::tr1::make_tuple;
namespace {
template<typename F, typename T>
class BlendMask6Test : public FunctionEquivalenceTest<F> {
protected:
virtual ~BlendMask6Test() {}
virtual void Execute(T *p_src0, T *p_src1) = 0;
void Common() {
w = 1 << randomise.uniform<int>(2, MAX_SB_SIZE_LOG2 + 1);
h = 1 << randomise.uniform<int>(2, MAX_SB_SIZE_LOG2 + 1);
randomise(subx);
randomise(suby);
randomise(dst_offset, 0, 32);
randomise(dst_stride, w, MAX_SB_SIZE * 5 + 1);
randomise(src0_offset, 0, 32);
randomise(src0_stride, w, MAX_SB_SIZE * 5 + 1);
randomise(src1_offset, 0, 32);
randomise(src1_stride, w, MAX_SB_SIZE * 5 + 1);
randomise(mask_stride, w * (subx ? 2: 1), 2 * MAX_SB_SIZE + 1);
T *p_src0;
T *p_src1;
switch (randomise.uniform<int>(3)) {
case 0: // Separate sources
p_src0 = &src0[0][0];
p_src1 = &src1[0][0];
break;
case 1: // src0 == dst
p_src0 = &dst_tst[0][0];
src0_stride = dst_stride;
src0_offset = dst_offset;
p_src1 = &src1[0][0];
break;
case 2: // src1 == dst
p_src0 = &src0[0][0];
p_src1 = &dst_tst[0][0];
src1_stride = dst_stride;
src1_offset = dst_offset;
break;
default:
FAIL();
}
//////////////////////////////////////////////////////////////////////////
// Prepare
//////////////////////////////////////////////////////////////////////////
snapshot(dst_ref);
snapshot(dst_tst);
snapshot(src0);
snapshot(src1);
snapshot(mask);
//////////////////////////////////////////////////////////////////////////
// Execute
//////////////////////////////////////////////////////////////////////////
Execute(p_src0, p_src1);
//////////////////////////////////////////////////////////////////////////
// Check
//////////////////////////////////////////////////////////////////////////
ASSERT_TRUE(BuffersEqWithin(dst_ref, dst_tst,
dst_stride, dst_stride,
dst_offset, dst_offset,
h, w));
ASSERT_TRUE(ArraysEq(snapshot.get(src0), src0));
ASSERT_TRUE(ArraysEq(snapshot.get(src1), src1));
ASSERT_TRUE(ArraysEq(snapshot.get(mask), mask));
ASSERT_TRUE(BuffersEqOutside(snapshot.get(dst_ref), dst_ref,
dst_stride,
dst_offset,
h, w));
ASSERT_TRUE(BuffersEqOutside(snapshot.get(dst_tst), dst_tst,
dst_stride,
dst_offset,
h, w));
}
Snapshot snapshot;
Randomise randomise;
T dst_ref[MAX_SB_SIZE][MAX_SB_SIZE * 5];
T dst_tst[MAX_SB_SIZE][MAX_SB_SIZE * 5];
size_t dst_stride;
size_t dst_offset;
T src0[MAX_SB_SIZE][MAX_SB_SIZE * 5];
size_t src0_stride;
size_t src0_offset;
T src1[MAX_SB_SIZE][MAX_SB_SIZE * 5];
size_t src1_stride;
size_t src1_offset;
uint8_t mask[2 * MAX_SB_SIZE][2 * MAX_SB_SIZE];
size_t mask_stride;
int w;
int h;
bool suby;
bool subx;
};
//////////////////////////////////////////////////////////////////////////////
// 8 bit version
//////////////////////////////////////////////////////////////////////////////
typedef void (*F8B)(uint8_t *dst, uint32_t dst_stride,
uint8_t *src0, uint32_t src0_stride,
uint8_t *src1, uint32_t src1_stride,
const uint8_t *mask, uint32_t mask_stride,
int h, int w, int suby, int subx);
class BlendMask6Test8B : public BlendMask6Test<F8B, uint8_t> {
protected:
void Execute(uint8_t *p_src0, uint8_t *p_src1) {
ref_func_(&dst_ref[0][dst_offset], dst_stride,
p_src0 + src0_offset, src0_stride,
p_src1 + src1_offset, src1_stride,
&mask[0][0], sizeof(mask[0]),
h, w, suby, subx);
ASM_REGISTER_STATE_CHECK(
tst_func_(&dst_tst[0][dst_offset], dst_stride,
p_src0 + src0_offset, src0_stride,
p_src1 + src1_offset, src1_stride,
&mask[0][0], sizeof(mask[0]),
h, w, suby, subx));
}
};
TEST_P(BlendMask6Test8B, RandomValues) {
for (int i = 0 ; i < 10000 && !HasFatalFailure(); i++) {
//////////////////////////////////////////////////////////////////////////
// Randomise
//////////////////////////////////////////////////////////////////////////
randomise(dst_ref);
randomise(dst_tst);
randomise(src0);
randomise(src1);
randomise(mask, 65);
Common();
}
}
TEST_P(BlendMask6Test8B, ExtremeValues) {
for (int i = 0 ; i < 1000 && !HasFatalFailure(); i++) {
//////////////////////////////////////////////////////////////////////////
// Randomise
//////////////////////////////////////////////////////////////////////////
randomise(dst_ref, 254, 256);
randomise(dst_tst, 254, 256);
randomise(src0, 254, 256);
randomise(src1, 254, 256);
randomise(mask, 63, 65);
Common();
}
}
#if HAVE_SSE4_1
INSTANTIATE_TEST_CASE_P(
SSE4_1_C_COMPARE, BlendMask6Test8B,
::testing::Values(make_tuple(&vpx_blend_mask6_c, &vpx_blend_mask6_sse4_1)));
#endif // HAVE_SSE4_1
#if CONFIG_VP9_HIGHBITDEPTH
//////////////////////////////////////////////////////////////////////////////
// High bit-depth version
//////////////////////////////////////////////////////////////////////////////
typedef void (*FHBD)(uint8_t *dst, uint32_t dst_stride,
uint8_t *src0, uint32_t src0_stride,
uint8_t *src1, uint32_t src1_stride,
const uint8_t *mask, uint32_t mask_stride,
int h, int w, int suby, int subx, int bd);
class BlendMask6TestHBD : public BlendMask6Test<FHBD, uint16_t> {
protected:
void Execute(uint16_t *p_src0, uint16_t *p_src1) {
ref_func_(CONVERT_TO_BYTEPTR(&dst_ref[0][dst_offset]), dst_stride,
CONVERT_TO_BYTEPTR(p_src0 + src0_offset), src0_stride,
CONVERT_TO_BYTEPTR(p_src1 + src1_offset), src1_stride,
&mask[0][0], sizeof(mask[0]),
h, w, suby, subx, bit_depth);
ASM_REGISTER_STATE_CHECK(
tst_func_(CONVERT_TO_BYTEPTR(&dst_tst[0][dst_offset]), dst_stride,
CONVERT_TO_BYTEPTR(p_src0 + src0_offset), src0_stride,
CONVERT_TO_BYTEPTR(p_src1 + src1_offset), src1_stride,
&mask[0][0], sizeof(mask[0]),
h, w, suby, subx, bit_depth));
}
int bit_depth;
};
TEST_P(BlendMask6TestHBD, RandomValues) {
for (int i = 0 ; i < 10000 && !HasFatalFailure(); i++) {
//////////////////////////////////////////////////////////////////////////
// Randomise
//////////////////////////////////////////////////////////////////////////
bit_depth = randomise.choice(8, 10, 12);
const int hi = 1 << bit_depth;
randomise(dst_ref, hi);
randomise(dst_tst, hi);
randomise(src0, hi);
randomise(src1, hi);
randomise(mask, 65);
Common();
}
}
TEST_P(BlendMask6TestHBD, ExtremeValues) {
for (int i = 0 ; i < 1000 && !HasFatalFailure(); i++) {
//////////////////////////////////////////////////////////////////////////
// Randomise
//////////////////////////////////////////////////////////////////////////
bit_depth = randomise.choice(8, 10, 12);
const int hi = 1 << bit_depth;
const int lo = hi - 2;
randomise(dst_ref, lo, hi);
randomise(dst_tst, lo, hi);
randomise(src0, lo, hi);
randomise(src1, lo, hi);
randomise(mask, 63, 65);
Common();
}
}
#if HAVE_SSE4_1
INSTANTIATE_TEST_CASE_P(
SSE4_1_C_COMPARE, BlendMask6TestHBD,
::testing::Values(make_tuple(&vpx_highbd_blend_mask6_c,
&vpx_highbd_blend_mask6_sse4_1)));
#endif // HAVE_SSE4_1
#endif // CONFIG_VP9_HIGHBITDEPTH
} // namespace
/*
* Copyright (c) 2016 The WebM project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef TEST_FUNCTION_EQUIVALENCE_TEST_H_
#define TEST_FUNCTION_EQUIVALENCE_TEST_H_
#include "third_party/googletest/src/include/gtest/gtest.h"
#include "test/clear_system_state.h"
#include "test/util.h"
namespace libvpx_test {
template <typename T>