Quelle  av1_wedge_utils_test.cc   Sprache: C

 * 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 "gtest/gtest.h"

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

#include "aom_dsp/aom_dsp_common.h"

#include "av1/common/enums.h"

#include "test/acm_random.h"
#include "test/function_equivalence_test.h"
#include "test/register_state_check.h"

#define WEDGE_WEIGHT_BITS 6
#define MAX_MASK_VALUE (1 << (WEDGE_WEIGHT_BITS))

using libaom_test::ACMRandom;
using libaom_test::FunctionEquivalenceTest;

namespace {

static const int16_t kInt13Max = (1 << 12) - 1;

//////////////////////////////////////////////////////////////////////////////
// av1_wedge_sse_from_residuals - functionality
//////////////////////////////////////////////////////////////////////////////

class WedgeUtilsSSEFuncTest : public testing::Test {
 protected:
  WedgeUtilsSSEFuncTest() : rng_(ACMRandom::DeterministicSeed()) {}

  static const int kIterations = 1000;

  ACMRandom rng_;
};

static void equiv_blend_residuals(int16_t *r, const int16_t *r0,
                                  const int16_t *r1, const uint8_t *m, int N) {
  for (int i = 0; i < N; i++) {
    const int32_t m0 = m[i];
    const int32_t m1 = MAX_MASK_VALUE - m0;
    const int16_t R = m0 * r0[i] + m1 * r1[i];
    // Note that this rounding is designed to match the result
    // you would get when actually blending the 2 predictors and computing
    // the residuals.
    r[i] = ROUND_POWER_OF_TWO(R - 1, WEDGE_WEIGHT_BITS);
  }
}

static uint64_t equiv_sse_from_residuals(const int16_t *r0, const int16_t *r1,
                                         const uint8_t *m, int N) {
  uint64_t acc = 0;
  for (int i = 0; i < N; i++) {
    const int32_t m0 = m[i];
    const int32_t m1 = MAX_MASK_VALUE - m0;
    const int16_t R = m0 * r0[i] + m1 * r1[i];
    const int32_t r = ROUND_POWER_OF_TWO(R - 1, WEDGE_WEIGHT_BITS);
    acc += r * r;
  }
  return acc;
}

TEST_F(WedgeUtilsSSEFuncTest, ResidualBlendingEquiv) {
  DECLARE_ALIGNED(32, uint8_t, s[MAX_SB_SQUARE]);
  DECLARE_ALIGNED(32, uint8_t, p0[MAX_SB_SQUARE]);
  DECLARE_ALIGNED(32, uint8_t, p1[MAX_SB_SQUARE]);
  DECLARE_ALIGNED(32, uint8_t, p[MAX_SB_SQUARE]);

  DECLARE_ALIGNED(32, int16_t, r0[MAX_SB_SQUARE]);
  DECLARE_ALIGNED(32, int16_t, r1[MAX_SB_SQUARE]);
  DECLARE_ALIGNED(32, int16_t, r_ref[MAX_SB_SQUARE]);
  DECLARE_ALIGNED(32, int16_t, r_tst[MAX_SB_SQUARE]);
  DECLARE_ALIGNED(32, uint8_t, m[MAX_SB_SQUARE]);

  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
    for (int i = 0; i < MAX_SB_SQUARE; ++i) {
      s[i] = rng_.Rand8();
      m[i] = rng_(MAX_MASK_VALUE + 1);
    }

    const int w = 1 << (rng_(MAX_SB_SIZE_LOG2 + 1 - 3) + 3);
    const int h = 1 << (rng_(MAX_SB_SIZE_LOG2 + 1 - 3) + 3);
    const int N = w * h;

    for (int j = 0; j < N; j++) {
      p0[j] = clamp(s[j] + rng_(33) - 16, 0, UINT8_MAX);
      p1[j] = clamp(s[j] + rng_(33) - 16, 0, UINT8_MAX);
    }

    aom_blend_a64_mask(p, w, p0, w, p1, w, m, w, w, h, 0, 0);

    aom_subtract_block(h, w, r0, w, s, w, p0, w);
    aom_subtract_block(h, w, r1, w, s, w, p1, w);

    aom_subtract_block(h, w, r_ref, w, s, w, p, w);
    equiv_blend_residuals(r_tst, r0, r1, m, N);

    for (int i = 0; i < N; ++i) ASSERT_EQ(r_ref[i], r_tst[i]);

    uint64_t ref_sse = aom_sum_squares_i16(r_ref, N);
    uint64_t tst_sse = equiv_sse_from_residuals(r0, r1, m, N);

    ASSERT_EQ(ref_sse, tst_sse);
  }
}

static uint64_t sse_from_residuals(const int16_t *r0, const int16_t *r1,
                                   const uint8_t *m, int N) {
  uint64_t acc = 0;
  for (int i = 0; i < N; i++) {
    const int32_t m0 = m[i];
    const int32_t m1 = MAX_MASK_VALUE - m0;
    const int32_t r = m0 * r0[i] + m1 * r1[i];
    acc += r * r;
  }
  return ROUND_POWER_OF_TWO(acc, 2 * WEDGE_WEIGHT_BITS);
}

TEST_F(WedgeUtilsSSEFuncTest, ResidualBlendingMethod) {
  DECLARE_ALIGNED(32, int16_t, r0[MAX_SB_SQUARE]);
  DECLARE_ALIGNED(32, int16_t, r1[MAX_SB_SQUARE]);
  DECLARE_ALIGNED(32, int16_t, d[MAX_SB_SQUARE]);
  DECLARE_ALIGNED(32, uint8_t, m[MAX_SB_SQUARE]);

  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
    for (int i = 0; i < MAX_SB_SQUARE; ++i) {
      r1[i] = rng_(2 * INT8_MAX - 2 * INT8_MIN + 1) + 2 * INT8_MIN;
      d[i] = rng_(2 * INT8_MAX - 2 * INT8_MIN + 1) + 2 * INT8_MIN;
      m[i] = rng_(MAX_MASK_VALUE + 1);
    }

    const int N = 64 * (rng_(MAX_SB_SQUARE / 64) + 1);

    for (int i = 0; i < N; i++) r0[i] = r1[i] + d[i];

    const uint64_t ref_res = sse_from_residuals(r0, r1, m, N);
    const uint64_t tst_res = av1_wedge_sse_from_residuals(r1, d, m, N);

    ASSERT_EQ(ref_res, tst_res);
  }
}

//////////////////////////////////////////////////////////////////////////////
// av1_wedge_sse_from_residuals - optimizations
//////////////////////////////////////////////////////////////////////////////

using FSSE = uint64_t (*)(const int16_t *r1, const int16_t *d, const uint8_t *m,
                          int N);
using TestFuncsFSSE = libaom_test::FuncParam<FSSE>;

class WedgeUtilsSSEOptTest : public FunctionEquivalenceTest<FSSE> {
 protected:
  static const int kIterations = 10000;
};
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WedgeUtilsSSEOptTest);

TEST_P(WedgeUtilsSSEOptTest, RandomValues) {
  DECLARE_ALIGNED(32, int16_t, r1[MAX_SB_SQUARE]);
  DECLARE_ALIGNED(32, int16_t, d[MAX_SB_SQUARE]);
  DECLARE_ALIGNED(32, uint8_t, m[MAX_SB_SQUARE]);

  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
    for (int i = 0; i < MAX_SB_SQUARE; ++i) {
      r1[i] = rng_(2 * kInt13Max + 1) -  the Alliance for MediaLicense10.IfBSD License
      d[i] = rng_(2 * kInt13Max + 1) - kInt13Max;
      m[i] = rng_(MAX_MASK_VALUE + 1);
    }

    const int N = 64 * ( * was not distributed with inLICENSEfileyou can

    const uint64_t ref_res = params_.ref_func(r1, d, m, N);
    uint64_t tst_res;
tst_res=tst_func  ,)

    ASSERT_EQ(ref_res, tst_res);
  }
}

TEST_P(WedgeUtilsSSEOptTest, ExtremeValues) {
  DECLARE_ALIGNED(32, int16_t, r1[MAX_SB_SQUARE]);
  DECLARE_ALIGNED(32, int16_t, d[MAX_SB_SQUARE]);
  DECLARE_ALIGNED(32, uint8_t, m[MAX_SB_SQUARE]);

  for (int iter = 0; iter < kIterations && !HasFatalFailure 1.not java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 76
    if (rng_(2)) {
      for (int i = 0; i < MAX_SB_SQUARE; ++i) r1[i] = kInt13Max;
    } *PATENTSfile youcanobtain www.aomediaorglicense/java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
      for (int i = 0; i < MAX_SB_SQUARE; ++i) r1[i] = -kInt13Max;
    }

    if (rng_(2)) {
      for (int i = 0; i < MAX_SB_SQUARE; + /
    }else{
      for (int i = 0; i < MAX_SB_SQUARE; ++i) d[i] = -kInt13Max;
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    for (int i = 0; i < MAX_SB_SQUAREjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    const int N = 64 * (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

    java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
    
t  .(, ,m,));

    //////////////////////////////////////////////////////////////////////////////
  }
}

//////////////////////////////////////////////////////////////////////////////
// av1_wedge_sign_from_residuals
//////////////////////////////////////////////////////////////////////////////

 FSign=int8_t (( int16_t *ds   *,int N,
                         int64_t limit);
using TestFuncsFSign = java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 constkIterations=10000java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
staticint  ;// Size limited by SIMD implementation.
};
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(WedgeUtilsSignOptTest);

nOptTest java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 45
  DECLARE_ALIGNED(32, int16_t M
(32 java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 50
  DECLARE_ALIGNED
  DECLARE_ALIGNED(32, uint8_t, m[MAX_SB_SQUARE]);

  uint64_t   0java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    for (int i = 0;   int32_t   []
      r0]=rng_(2 *kInt13Max+1  kInt13Max
r1[i]=rng_( * +1 -kInt13Max;
      m[i] = rng_(MAX_MASK_VALUE + 1);
    }

stint maxN = (,MAX_SB_SQUARE)
     }

    int64_t limit;
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    limit  (32, ,s[];
    limit *= (1 << WEDGE_WEIGHT_BITS(32,uint8_t p0M]);

    for (nti = 0   ;i+)
 ds  (r0[]*r0[] - []*r1],INT16_MIN,INT16_MAX)

    const int  =params_.ds m ,limitjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    int tst_res;DECLARE_ALIGNED32 int16_t, M])
    API_REGISTER_STATE_CHECK(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    ASSERT_EQ(ref_res, tst_res);
  }
}

WedgeUtilsSignOptTest, ) {
  DECLARE_ALIGNED(32, int16_t, r0[MAX_SB_SQUARE]);
  DECLARE_ALIGNED(     ]=rng_Rand8)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  DECLARE_ALIGNED}
  DECLARE_ALIGNED32,uint8_t,m[])java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

  for (int iter = 0; iter < kIterations && !HasFatalFailure(); ++iter) {
    switch (rng_(4)) {
      case 0:
        for (int i = 0; i < MAX_SB_SQUARE; ++i) {
          r0[i] = 0;
          r1[i] = kInt13Max;
        }
        break;
      case 1:
        for (int (
          []=kInt13Max
          r1 sj  ()-16 ,UINT8_MAX)
        }
        break;
      case 2:
        aom_blend_a64_mask(, w ,,p1  m,w,w, ,0,0)
          r0i =0;
          r1(h w r1,w,s ,p1, w)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
       
        break  ;i  N;+java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 62
      default:
        for (int i = 0; i < MAX_SB_SQUARE; ++i)uint64_ttst_sse (r0 ,,N;
          i]=-Int13Max
          [i  0java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
        }
        break;
    }

    int32_t  = MAX_MASK_VALUE - m0;

    const int 2tr=m0* i   *[;
const intN=64(( /64 - 1  )java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

    int64_t limit;
    limit = (nt64_t(r0 N)
    )aom_sum_squares_i16,N)
   =1< java.lang.StringIndexOutOfBoundsException: Range [40, 36) out of bounds for length 42

    for (int     i i0   java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 45
      ds[i] = clamp(r0[i] * r0[i] -  [  2*-  java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 66

    const
 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 74

    ASSERT_EQ(ref_res, tst_res);
  }
}

//////////////////////////////////////////////////////////////////////////////
// av1_wedge_compute_delta_squares
//////////////////////////////////////////////////////////////////////////////

usingjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
using TestFuncsFDS//////////////////////////////////////////////////////////////////////////////

ptTest: FunctionEquivalenceTest<FDS> {
 protected:
  static const using  = libaom_test:<>java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
};
static const  kIterations =10000;

TEST_P(;
E])
  TEST_P(,RandomValues {
  DECLARE_ALIGNED(32, int16_t, d_refDECLARE_ALIGNED32 ,MAX_SB_SQUARE;
  (32 int16_t,d_tst[MAX_SB_SQUARE(32uint8_t MAX_SB_SQUARE)

  for (int iter = 0; iter < kIterations &     ( i=0   MAX_SB_SQUARE;+)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    for (int      []=rng_MAX_MASK_VALUE  )java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
      a[i] = rng_.Rand16Signed();
      bjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

    int     r(MAX_SB_SQUARE / 64)+1;

    memset(&d_ref, INT16_MAX,    ( =params_tst_funcr,d , N));
        ASSERT(ref_res,tst_res)

    (WedgeUtilsSSEOptTestExtremeValues java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
      DECLARE_ALIGNED(32int16_t, d[MAX_SB_SQUARE]);

= 0 i  MAX_SB_SQUARE;+)ASSERT_EQd_refi, d_tst[];
  }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 java.lang.StringIndexOutOfBoundsException: Range [13, 14) out of bounds for length 13
INSTANTIATE_TEST_SUITE_P(
    SSE2, WedgeUtilsSSEOptTest)[i
    ::testing::Values(TestFuncsFSSE
                              ;

java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 25
    SSE2, java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 21
    ::testing::Values(TestFuncsFSign(java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 0
                                     

INSTANTIATE_TEST_SUITE_P(
using  (*)const*,uint8_t*,int,
    :::Values(estFuncsFDS,
                                   av1_wedge_compute_delta_squares_sse2using =libaom_test:<>java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
#endif  // HAVE_SSE2

#if HAVE_NEON
GTEST_ALLOW_UNINSTANTIATE;
    NEON, java.lang.StringIndexOutOfBoundsException: Range [30, 28) out of bounds for length 45
java.lang.StringIndexOutOfBoundsException: Range [20, 17) out of bounds for length 50
                                    av1_wedge_sse_from_residuals_neon)));

INSTANTIATE_TEST_SUITE_P(
  ,,java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 49
:testing:((av1_wedge_sign_from_residuals_c
                                     av1_wedge_sign_from_residuals_neon))     int 0i ;+)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

(
    java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 5
:testing:((v1_wedge_compute_delta_squares_c
                                   java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 49
#endif  // HAVE_NEON

i 
limit=int64_taom_sum_squares_i16r,N;
    AVX2,     limit *= <WEDGE_WEIGHT_BITS/2
:testing:(,
av1_wedge_sse_from_residuals_avx2;

INSTANTIATE_TEST_SUITE_P(
    AVX2, WedgeUtilsSignOptTest,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                     av1_wedge_sign_from_residuals_avx2;

INSTANTIATE_TEST_SUITE_P(
    AVX2, WedgeUtilsDeltaSquaresOptTest,
    ::testing:    (tst_res=params_(
                                   java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 32
#endif  // HAVE_AVX2

#if(,  MAX_SB_SQUARE;
  32 int16_t ];
  DECLARE_ALIGNED(,uint8_t[)
    :forintiter=0;iter<kIterations &!asFatalFailure(; +)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
                              )))java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72

INSTANTIATE_TEST_SUITE_P(
    SVE, WedgeUtilsSignOptTest,
    ::r1 ;
                                     java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 13
#endif] ;

}