a661bc87c4
This is to replace vp10/common/reconinter.c:build_masked_compound. Functionality is equivalent, but the interface is slightly more generic. Total encoder speedup with ext-inter: ~7.5% Change-Id: Iee18b83ae324ffc9c7f7dc16d4b2b06adb4d4305
279 lines
8.3 KiB
C++
279 lines
8.3 KiB
C++
/*
|
|
* 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_
|