History

Add arm UT for Sad,IntraSad,IntraPred.

zhiliang wang committed 12 years ago

Commit e6f838e1 parent 3f839e33 files · +288 −441Browse files

Showing the changes to test/encoder/EncUT_Sample.cpp (1 of 3 files). Show all

Unified · Split

test/encoder/EncUT_Sample.cpp+260−441
@@ -8,136 +8,123 @@ · 7 unmodified lines
88 #include "get_intra_predictor.h"
99
1010 using namespace WelsEnc;
11−#ifdef X86_ASM
12−TEST (IntraSadSatdFuncTest, WelsIntra16x16Combined3Sad_ssse3) {
13− const int32_t iLineSizeDec = 32;
14− const int32_t iLineSizeEnc = 32;
15− int32_t tmpa, tmpb;
16− int32_t iBestMode_c, iBestMode_a, iLambda = 50;
17− CMemoryAlign cMemoryAlign (0);
18− int32_t iCpuCores = 0;
19− uint32_t m_uiCpuFeatureFlag = WelsCPUFeatureDetect (&iCpuCores);
20− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSSE3))
21− return;
22− uint8_t* pDec = (uint8_t*)cMemoryAlign.WelsMalloc (iLineSizeDec << 5, "pDec");
23− uint8_t* pEnc = (uint8_t*)cMemoryAlign.WelsMalloc (iLineSizeEnc << 5, "pEnc");
24− uint8_t* pDst = (uint8_t*)cMemoryAlign.WelsMalloc (512, "pDst");
25− for (int i = 0; i < (iLineSizeDec << 5); i++)
26− pDec[i] = rand() % 256;
27− for (int i = 0; i < (iLineSizeEnc << 5); i++)
28− pEnc[i] = rand() % 256;
29−
30− for (int i = 0; i < 512; i++)
31− pDst[i] = rand() % 256;
32− tmpa = WelsSampleSadIntra16x16Combined3_c (pDec + 128, iLineSizeDec, pEnc, iLineSizeEnc, &iBestMode_c, iLambda, pDst);
33− tmpb = WelsIntra16x16Combined3Sad_ssse3 (pDec + 128, iLineSizeDec, pEnc, iLineSizeEnc, &iBestMode_a, iLambda, pDst);
34−
35− ASSERT_EQ (tmpa, tmpb);
36− ASSERT_EQ (iBestMode_c, iBestMode_a);
37−
38− cMemoryAlign.WelsFree (pDec, "pDec");
39− cMemoryAlign.WelsFree (pEnc, "pEnc");
40− cMemoryAlign.WelsFree (pDst, "pDst");
41−}
4211
43−TEST (IntraSadSatdFuncTest, WelsIntra16x16Combined3Satd_sse41) {
44− const int32_t iLineSizeDec = 32;
45− const int32_t iLineSizeEnc = 32;
46− int32_t tmpa, tmpb;
47− int32_t iBestMode_c, iBestMode_a, iLambda = 50;
48− CMemoryAlign cMemoryAlign (0);
49− int32_t iCpuCores = 0;
50− uint32_t m_uiCpuFeatureFlag = WelsCPUFeatureDetect (&iCpuCores);
51− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE41))
52− return;
53− uint8_t* pDec = (uint8_t*)cMemoryAlign.WelsMalloc (iLineSizeDec << 5, "pDec");
54− uint8_t* pEnc = (uint8_t*)cMemoryAlign.WelsMalloc (iLineSizeEnc << 5, "pEnc");
55− uint8_t* pDst = (uint8_t*)cMemoryAlign.WelsMalloc (512, "pDst");
56− for (int i = 0; i < (iLineSizeDec << 5); i++)
57− pDec[i] = rand() % 256;
58− for (int i = 0; i < (iLineSizeEnc << 5); i++)
59− pEnc[i] = rand() % 256;
60− for (int i = 0; i < 512; i++)
61− pDst[i] = rand() % 256;
62− tmpa = WelsSampleSatdIntra16x16Combined3_c (pDec + 128, iLineSizeDec, pEnc, iLineSizeEnc, &iBestMode_c, iLambda, pDst);
63− tmpb = WelsIntra16x16Combined3Satd_sse41 (pDec + 128, iLineSizeDec, pEnc, iLineSizeEnc, &iBestMode_a, iLambda, pDst);
64− ASSERT_EQ (tmpa, tmpb);
65− ASSERT_EQ (iBestMode_c, iBestMode_a);
66− cMemoryAlign.WelsFree (pDec, "pDec");
67− cMemoryAlign.WelsFree (pEnc, "pEnc");
68− cMemoryAlign.WelsFree (pDst, "pDst");
12+#define GENERATE_Intra16x16_UT(func, ref, ASM, CPUFLAGS) \
13+TEST (IntraSadSatdFuncTest, func) { \
14+ const int32_t iLineSizeDec = 32; \
15+ const int32_t iLineSizeEnc = 32; \
16+ int32_t tmpa, tmpb; \
17+ int32_t iBestMode_c, iBestMode_a, iLambda = 50; \
18+ if (ASM) {\
19+ int32_t iCpuCores = 0; \
20+ uint32_t m_uiCpuFeatureFlag = WelsCPUFeatureDetect (&iCpuCores); \
21+ if (0 == (m_uiCpuFeatureFlag & CPUFLAGS)) \
22+ return; \
23+ } \
24+ ENFORCE_STACK_ALIGN_1D (uint8_t, pDec, iLineSizeDec << 5, 16); \
25+ ENFORCE_STACK_ALIGN_1D (uint8_t, pEnc, iLineSizeEnc << 5, 16); \
26+ ENFORCE_STACK_ALIGN_1D (uint8_t, pDst, 512, 16); \
27+ for (int i = 0; i < (iLineSizeDec << 5); i++) \
28+ pDec[i] = rand() % 256; \
29+ for (int i = 0; i < (iLineSizeEnc << 5); i++) \
30+ pEnc[i] = rand() % 256; \
31+ for (int i = 0; i < 512; i++) \
32+ pDst[i] = rand() % 256; \
33+ tmpa = ref (pDec + 128, iLineSizeDec, pEnc, iLineSizeEnc, &iBestMode_c, iLambda, pDst); \
34+ tmpb = func (pDec + 128, iLineSizeDec, pEnc, iLineSizeEnc, &iBestMode_a, iLambda, pDst); \
35+ ASSERT_EQ (tmpa, tmpb); \
36+ ASSERT_EQ (iBestMode_c, iBestMode_a); \
37+}
38+
39+#define GENERATE_Intra4x4_UT(func, ASM, CPUFLAGS) \
40+TEST (IntraSadSatdFuncTest, func) { \
41+ const int32_t iLineSizeDec = 32; \
42+ const int32_t iLineSizeEnc = 32; \
43+ int32_t tmpa, tmpb; \
44+ int32_t iBestMode_c, iBestMode_a, iLambda = 50; \
45+ int32_t lambda[2] = {iLambda << 2, iLambda}; \
46+ int32_t iPredMode = rand() % 3; \
47+ if (ASM) {\
48+ int32_t iCpuCores = 0; \
49+ uint32_t m_uiCpuFeatureFlag = WelsCPUFeatureDetect (&iCpuCores); \
50+ if (0 == (m_uiCpuFeatureFlag & CPUFLAGS)) \
51+ return; \
52+ } \
53+ ENFORCE_STACK_ALIGN_1D (uint8_t, pDec, iLineSizeDec << 5, 16); \
54+ ENFORCE_STACK_ALIGN_1D (uint8_t, pEnc, iLineSizeEnc << 5, 16); \
55+ ENFORCE_STACK_ALIGN_1D (uint8_t, pDst, 512, 16); \
56+ for (int i = 0; i < (iLineSizeDec << 5); i++) \
57+ pDec[i] = rand() % 256; \
58+ for (int i = 0; i < (iLineSizeEnc << 5); i++) \
59+ pEnc[i] = rand() % 256; \
60+ for (int i = 0; i < 512; i++) \
61+ pDst[i] = rand() % 256; \
62+ tmpa = WelsSampleSatdIntra4x4Combined3_c (pDec + 128, iLineSizeDec, pEnc, iLineSizeEnc, pDst, &iBestMode_c, \
63+ lambda[iPredMode == 2], lambda[iPredMode == 1], lambda[iPredMode == 0]); \
64+ tmpb = func (pDec + 128, iLineSizeDec, pEnc, iLineSizeEnc, pDst, &iBestMode_a, \
65+ lambda[iPredMode == 2], lambda[iPredMode == 1], lambda[iPredMode == 0]); \
66+ ASSERT_EQ (tmpa, tmpb); \
67+ ASSERT_EQ (iBestMode_c, iBestMode_a); \
68+}
69+
70+#define GENERATE_Intra8x8_UT(func, ref, ASM, CPUFLAGS) \
71+TEST (IntraSadSatdFuncTest, func) { \
72+ const int32_t iLineSizeDec = 32; \
73+ const int32_t iLineSizeEnc = 32; \
74+ int32_t tmpa, tmpb; \
75+ int32_t iBestMode_c, iBestMode_a, iLambda = 50; \
76+ if (ASM) {\
77+ int32_t iCpuCores = 0; \
78+ uint32_t m_uiCpuFeatureFlag = WelsCPUFeatureDetect (&iCpuCores); \
79+ if (0 == (m_uiCpuFeatureFlag & CPUFLAGS)) \
80+ return; \
81+ } \
82+ ENFORCE_STACK_ALIGN_1D (uint8_t, pDecCb, iLineSizeDec << 5, 16); \
83+ ENFORCE_STACK_ALIGN_1D (uint8_t, pEncCb, iLineSizeEnc << 5, 16); \
84+ ENFORCE_STACK_ALIGN_1D (uint8_t, pDecCr, iLineSizeDec << 5, 16); \
85+ ENFORCE_STACK_ALIGN_1D (uint8_t, pEncCr, iLineSizeEnc << 5, 16); \
86+ ENFORCE_STACK_ALIGN_1D (uint8_t, pDstChma, 512, 16); \
87+ for (int i = 0; i < (iLineSizeDec << 5); i++) { \
88+ pDecCb[i] = rand() % 256; \
89+ pDecCr[i] = rand() % 256; \
90+ } \
91+ for (int i = 0; i < (iLineSizeEnc << 5); i++) { \
92+ pEncCb[i] = rand() % 256; \
93+ pEncCr[i] = rand() % 256; \
94+ } \
95+ for (int i = 0; i < 512; i++) \
96+ pDstChma[i] = rand() % 256; \
97+ tmpa = ref (pDecCb + 128, iLineSizeDec, pEncCb, iLineSizeEnc, &iBestMode_c, iLambda, \
98+ pDstChma, pDecCr + 128, pEncCr); \
99+ tmpb = func (pDecCb + 128, iLineSizeDec, pEncCb, iLineSizeEnc, &iBestMode_a, iLambda, \
100+ pDstChma, pDecCr + 128, pEncCr); \
101+ ASSERT_EQ (tmpa, tmpb); \
102+ ASSERT_EQ (iBestMode_c, iBestMode_a); \
69103 }
70104
71−TEST (IntraSadSatdFuncTest, WelsSampleSatdThree4x4_sse2) {
72− const int32_t iLineSizeDec = 32;
73− const int32_t iLineSizeEnc = 32;
74− int32_t tmpa, tmpb;
75− int32_t iBestMode_c, iBestMode_a, iLambda = 50;
76− int32_t lambda[2] = {iLambda << 2, iLambda};
77− int32_t iPredMode = rand() % 3;
78− CMemoryAlign cMemoryAlign (0);
79− int32_t iCpuCores = 0;
80− uint32_t m_uiCpuFeatureFlag = WelsCPUFeatureDetect (&iCpuCores);
81− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2))
82− return;
83− uint8_t* pDec = (uint8_t*)cMemoryAlign.WelsMalloc (iLineSizeDec << 5, "pDec");
84− uint8_t* pEnc = (uint8_t*)cMemoryAlign.WelsMalloc (iLineSizeEnc << 5, "pEnc");
85− uint8_t* pDst = (uint8_t*)cMemoryAlign.WelsMalloc (512, "pDst");
86− for (int i = 0; i < (iLineSizeDec << 5); i++)
87− pDec[i] = rand() % 256;
88− for (int i = 0; i < (iLineSizeEnc << 5); i++)
89− pEnc[i] = rand() % 256;
90− for (int i = 0; i < 512; i++)
91− pDst[i] = rand() % 256;
92− tmpa = WelsSampleSatdIntra4x4Combined3_c (pDec + 128, iLineSizeDec, pEnc, iLineSizeEnc, pDst, &iBestMode_c,
93− lambda[iPredMode == 2], lambda[iPredMode == 1], lambda[iPredMode == 0]);
94− tmpb = WelsSampleSatdThree4x4_sse2 (pDec + 128, iLineSizeDec, pEnc, iLineSizeEnc, pDst, &iBestMode_a,
95− lambda[iPredMode == 2], lambda[iPredMode == 1], lambda[iPredMode == 0]);
96− ASSERT_EQ (tmpa, tmpb);
97− ASSERT_EQ (iBestMode_c, iBestMode_a);
98− cMemoryAlign.WelsFree (pDec, "pDec");
99− cMemoryAlign.WelsFree (pEnc, "pEnc");
100− cMemoryAlign.WelsFree (pDst, "pDst");
101−}
105+#ifdef X86_ASM
106+GENERATE_Intra16x16_UT(WelsIntra16x16Combined3Sad_ssse3, WelsSampleSadIntra16x16Combined3_c, 1, WELS_CPU_SSSE3)
107+GENERATE_Intra16x16_UT(WelsIntra16x16Combined3Satd_sse41, WelsSampleSatdIntra16x16Combined3_c, 1, WELS_CPU_SSE41)
108+GENERATE_Intra8x8_UT(WelsIntraChroma8x8Combined3Satd_sse41, WelsSampleSatdIntra8x8Combined3_c, 1, WELS_CPU_SSE41)
109+GENERATE_Intra4x4_UT(WelsSampleSatdThree4x4_sse2, 1, WELS_CPU_SSE2)
110+#endif
102111
103−TEST (IntraSadSatdFuncTest, WelsIntraChroma8x8Combined3Satd_sse41) {
104− const int32_t iLineSizeDec = 32;
105− const int32_t iLineSizeEnc = 32;
106− int32_t tmpa, tmpb;
107− int32_t iBestMode_c, iBestMode_a, iLambda = 50;
108− CMemoryAlign cMemoryAlign (0);
109− int32_t iCpuCores = 0;
110− uint32_t m_uiCpuFeatureFlag = WelsCPUFeatureDetect (&iCpuCores);
111− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE41))
112− return;
113− uint8_t* pDecCb = (uint8_t*)cMemoryAlign.WelsMalloc (iLineSizeDec << 5, "pDecCb");
114− uint8_t* pEncCb = (uint8_t*)cMemoryAlign.WelsMalloc (iLineSizeEnc << 5, "pEncCb");
115− uint8_t* pDecCr = (uint8_t*)cMemoryAlign.WelsMalloc (iLineSizeDec << 5, "pDecCr");
116− uint8_t* pEncCr = (uint8_t*)cMemoryAlign.WelsMalloc (iLineSizeEnc << 5, "pEncCr");
117− uint8_t* pDstChma = (uint8_t*)cMemoryAlign.WelsMalloc (512, "pDstChma");
118− for (int i = 0; i < (iLineSizeDec << 5); i++) {
119− pDecCb[i] = rand() % 256;
120− pDecCr[i] = rand() % 256;
121− }
122− for (int i = 0; i < (iLineSizeEnc << 5); i++) {
123− pEncCb[i] = rand() % 256;
124− pEncCr[i] = rand() % 256;
125− }
126− for (int i = 0; i < 512; i++)
127− pDstChma[i] = rand() % 256;
128− tmpa = WelsSampleSatdIntra8x8Combined3_c (pDecCb + 128, iLineSizeDec, pEncCb, iLineSizeEnc, &iBestMode_c, iLambda,
129− pDstChma, pDecCr + 128, pEncCr);
130− tmpb = WelsIntraChroma8x8Combined3Satd_sse41 (pDecCb + 128, iLineSizeDec, pEncCb, iLineSizeEnc, &iBestMode_a, iLambda,
131− pDstChma, pDecCr + 128, pEncCr);
132− ASSERT_EQ (tmpa, tmpb);
133− ASSERT_EQ (iBestMode_c, iBestMode_a);
134− cMemoryAlign.WelsFree (pDecCb, "pDecCb");
135− cMemoryAlign.WelsFree (pEncCb, "pEncCb");
136− cMemoryAlign.WelsFree (pDecCr, "pDecCr");
137− cMemoryAlign.WelsFree (pEncCr, "pEncCr");
138− cMemoryAlign.WelsFree (pDstChma, "pDstChma");
139−}
112+#ifdef HAVE_NEON
113+GENERATE_Intra16x16_UT(WelsIntra16x16Combined3Sad_neon, WelsSampleSadIntra16x16Combined3_c, 1, WELS_CPU_NEON)
114+GENERATE_Intra16x16_UT(WelsIntra16x16Combined3Satd_neon, WelsSampleSatdIntra16x16Combined3_c, 1, WELS_CPU_NEON)
115+GENERATE_Intra8x8_UT(WelsIntra8x8Combined3Satd_neon, WelsSampleSatdIntra8x8Combined3_c, 1, WELS_CPU_NEON)
116+GENERATE_Intra8x8_UT(WelsIntra8x8Combined3Sad_neon, WelsSampleSadIntra8x8Combined3_c, 1, WELS_CPU_NEON)
117+GENERATE_Intra4x4_UT(WelsIntra4x4Combined3Satd_neon, 1, WELS_CPU_NEON)
140118 #endif
119+
120+#ifdef HAVE_NEON_AARCH64
121+GENERATE_Intra16x16_UT(WelsIntra16x16Combined3Sad_AArch64_neon, WelsSampleSadIntra16x16Combined3_c, 1, WELS_CPU_NEON)
122+GENERATE_Intra16x16_UT(WelsIntra16x16Combined3Satd_AArch64_neon, WelsSampleSatdIntra16x16Combined3_c, 1, WELS_CPU_NEON)
123+GENERATE_Intra8x8_UT(WelsIntra8x8Combined3Satd_AArch64_neon, WelsSampleSatdIntra8x8Combined3_c, 1, WELS_CPU_NEON)
124+GENERATE_Intra8x8_UT(WelsIntra8x8Combined3Sad_AArch64_neon, WelsSampleSadIntra8x8Combined3_c, 1, WELS_CPU_NEON)
125+GENERATE_Intra4x4_UT(WelsIntra4x4Combined3Satd_AArch64_neon, 1, WELS_CPU_NEON)
126+#endif
127+
141128 #define ASSERT_MEMORY_FAIL2X(A, B) \
142129 if (NULL == B) { \
143130 pMemAlign->WelsFree(A, "Sad_SrcA");\
@@ -457,7 +444,7 @@ TEST_F (SadSatdCFuncTest, WelsSampleSadFour4x4_c) { · 313 unmodified lines
457444 EXPECT_EQ (m_pSad[0] + m_pSad[1] + m_pSad[2] + m_pSad[3], iSumSad);
458445 }
459446
460−#ifdef X86_ASM
447+
461448 class SadSatdAssemblyFuncTest : public testing::Test {
462449 public:
463450 virtual void SetUp() {
@@ -489,327 +476,159 @@ class SadSatdAssemblyFuncTest : public testing::Test { · 25 unmodified lines
489476 CMemoryAlign* pMemAlign;
490477 };
491478
492−TEST_F (SadSatdAssemblyFuncTest, WelsSampleSad4x4_mmx) {
493− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_MMXEXT))
494− return;
495−
496− for (int i = 0; i < (m_iStrideA << 2); i++)
497− m_pPixSrcA[i] = rand() % 256;
498− for (int i = 0; i < (m_iStrideB << 2); i++)
499− m_pPixSrcB[i] = rand() % 256;
500−
501− EXPECT_EQ (WelsSampleSad4x4_c (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), WelsSampleSad4x4_mmx (m_pPixSrcA,
502− m_iStrideA, m_pPixSrcB, m_iStrideB));
503−}
504−
505−
506−TEST_F (SadSatdAssemblyFuncTest, WelsSampleSad8x8_sse21) {
507− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2))
508− return;
509−
510− for (int i = 0; i < (m_iStrideA << 3); i++)
511− m_pPixSrcA[i] = rand() % 256;
512− for (int i = 0; i < (m_iStrideB << 3); i++)
513− m_pPixSrcB[i] = rand() % 256;
514−
515− EXPECT_EQ (WelsSampleSad8x8_c (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), WelsSampleSad8x8_sse21 (m_pPixSrcA,
516− m_iStrideA, m_pPixSrcB, m_iStrideB));
517−}
518−
519−TEST_F (SadSatdAssemblyFuncTest, WelsSampleSad8x16_sse2) {
520− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2))
521− return;
522− for (int i = 0; i < (m_iStrideA << 4); i++)
523− m_pPixSrcA[i] = rand() % 256;
524− for (int i = 0; i < (m_iStrideB << 4); i++)
525− m_pPixSrcB[i] = rand() % 256;
526−
527− EXPECT_EQ (WelsSampleSad8x16_c (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), WelsSampleSad8x16_sse2 (m_pPixSrcA,
528− m_iStrideA, m_pPixSrcB, m_iStrideB));
529−}
530−
531−TEST_F (SadSatdAssemblyFuncTest, WelsSampleSad16x8_sse2) {
532− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2))
533− return;
534− for (int i = 0; i < (m_iStrideA << 3); i++)
535− m_pPixSrcA[i] = rand() % 256;
536− for (int i = 0; i < (m_iStrideB << 3); i++)
537− m_pPixSrcB[i] = rand() % 256;
538−
539− EXPECT_EQ (WelsSampleSad16x8_c (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), WelsSampleSad16x8_sse2 (m_pPixSrcA,
540− m_iStrideA, m_pPixSrcB, m_iStrideB));
541−}
542−
543−TEST_F (SadSatdAssemblyFuncTest, WelsSampleSad16x16_sse2) {
544− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2))
545− return;
546− for (int i = 0; i < (m_iStrideA << 4); i++)
547− m_pPixSrcA[i] = rand() % 256;
548− for (int i = 0; i < (m_iStrideB << 4); i++)
549− m_pPixSrcB[i] = rand() % 256;
550−
551− EXPECT_EQ (WelsSampleSad16x16_c (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), WelsSampleSad16x16_sse2 (m_pPixSrcA,
552− m_iStrideA, m_pPixSrcB, m_iStrideB));
553−}
554−
555−TEST_F (SadSatdAssemblyFuncTest, WelsSampleSatd4x4_sse2) {
556− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2))
557− return;
558− for (int i = 0; i < (m_iStrideA << 2); i++)
559− m_pPixSrcA[i] = rand() % 256;
560− for (int i = 0; i < (m_iStrideB << 2); i++)
561− m_pPixSrcB[i] = rand() % 256;
562−
563− EXPECT_EQ (WelsSampleSatd4x4_c (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), WelsSampleSatd4x4_sse2 (m_pPixSrcA,
564− m_iStrideA, m_pPixSrcB, m_iStrideB));
565−}
566−
567−TEST_F (SadSatdAssemblyFuncTest, WelsSampleSatd8x8_sse2) {
568− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2))
569− return;
570− for (int i = 0; i < (m_iStrideA << 3); i++)
571− m_pPixSrcA[i] = rand() % 256;
572− for (int i = 0; i < (m_iStrideB << 3); i++)
573− m_pPixSrcB[i] = rand() % 256;
574−
575− EXPECT_EQ (WelsSampleSatd8x8_c (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), WelsSampleSatd8x8_sse2 (m_pPixSrcA,
576− m_iStrideA, m_pPixSrcB, m_iStrideB));
577−}
578−
579−TEST_F (SadSatdAssemblyFuncTest, WelsSampleSatd8x16_sse2) {
580− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2))
581− return;
582− for (int i = 0; i < (m_iStrideA << 4); i++)
583− m_pPixSrcA[i] = rand() % 256;
584− for (int i = 0; i < (m_iStrideB << 4); i++)
585− m_pPixSrcB[i] = rand() % 256;
586−
587− EXPECT_EQ (WelsSampleSatd8x16_c (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), WelsSampleSatd8x16_sse2 (m_pPixSrcA,
588− m_iStrideA, m_pPixSrcB, m_iStrideB));
589−}
590−
591−TEST_F (SadSatdAssemblyFuncTest, WelsSampleSatd16x8_sse2) {
592− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2))
593− return;
594− for (int i = 0; i < (m_iStrideA << 3); i++)
595− m_pPixSrcA[i] = rand() % 256;
596− for (int i = 0; i < (m_iStrideB << 3); i++)
597− m_pPixSrcB[i] = rand() % 256;
598−
599− EXPECT_EQ (WelsSampleSatd16x8_c (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), WelsSampleSatd16x8_sse2 (m_pPixSrcA,
600− m_iStrideA, m_pPixSrcB, m_iStrideB));
601−}
602−
603−TEST_F (SadSatdAssemblyFuncTest, WelsSampleSatd16x16_sse2) {
604− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2))
605− return;
606− for (int i = 0; i < (m_iStrideA << 4); i++)
607− m_pPixSrcA[i] = rand() % 256;
608− for (int i = 0; i < (m_iStrideB << 4); i++)
609− m_pPixSrcB[i] = rand() % 256;
610−
611− EXPECT_EQ (WelsSampleSatd16x16_c (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), WelsSampleSatd16x16_sse2 (m_pPixSrcA,
612− m_iStrideA, m_pPixSrcB, m_iStrideB));
613−}
614−
615−TEST_F (SadSatdAssemblyFuncTest, WelsSampleSatd4x4_sse41) {
616− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE41))
617− return;
618− for (int i = 0; i < (m_iStrideA << 2); i++)
619− m_pPixSrcA[i] = rand() % 256;
620− for (int i = 0; i < (m_iStrideB << 2); i++)
621− m_pPixSrcB[i] = rand() % 256;
622−
623− EXPECT_EQ (WelsSampleSatd4x4_c (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), WelsSampleSatd4x4_sse41 (m_pPixSrcA,
624− m_iStrideA, m_pPixSrcB, m_iStrideB));
625−}
626−
627−TEST_F (SadSatdAssemblyFuncTest, WelsSampleSatd8x8_sse41) {
628− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE41))
629− return;
630− for (int i = 0; i < (m_iStrideA << 3); i++)
631− m_pPixSrcA[i] = rand() % 256;
632− for (int i = 0; i < (m_iStrideB << 3); i++)
633− m_pPixSrcB[i] = rand() % 256;
634−
635− EXPECT_EQ (WelsSampleSatd8x8_c (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), WelsSampleSatd8x8_sse41 (m_pPixSrcA,
636− m_iStrideA, m_pPixSrcB, m_iStrideB));
637−}
638−
639−TEST_F (SadSatdAssemblyFuncTest, WelsSampleSatd8x16_sse41) {
640− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE41))
641− return;
642− for (int i = 0; i < (m_iStrideA << 4); i++)
643− m_pPixSrcA[i] = rand() % 256;
644− for (int i = 0; i < (m_iStrideB << 4); i++)
645− m_pPixSrcB[i] = rand() % 256;
646−
647− EXPECT_EQ (WelsSampleSatd8x16_c (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), WelsSampleSatd8x16_sse41 (m_pPixSrcA,
648− m_iStrideA, m_pPixSrcB, m_iStrideB));
649−}
650−
651−TEST_F (SadSatdAssemblyFuncTest, WelsSampleSatd16x8_sse41) {
652− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE41))
653− return;
654− for (int i = 0; i < (m_iStrideA << 3); i++)
655− m_pPixSrcA[i] = rand() % 256;
656− for (int i = 0; i < (m_iStrideB << 3); i++)
657− m_pPixSrcB[i] = rand() % 256;
658−
659− EXPECT_EQ (WelsSampleSatd16x8_c (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), WelsSampleSatd16x8_sse41 (m_pPixSrcA,
660− m_iStrideA, m_pPixSrcB, m_iStrideB));
661−}
662−
663−TEST_F (SadSatdAssemblyFuncTest, WelsSampleSatd16x16_sse41) {
664− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE41))
665− return;
666− for (int i = 0; i < (m_iStrideA << 4); i++)
667− m_pPixSrcA[i] = rand() % 256;
668− for (int i = 0; i < (m_iStrideB << 4); i++)
669− m_pPixSrcB[i] = rand() % 256;
670−
671− EXPECT_EQ (WelsSampleSatd16x16_c (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB),
672− WelsSampleSatd16x16_sse41 (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB));
673−}
674−
675−TEST_F (SadSatdAssemblyFuncTest, WelsSampleSadFour16x16_sse2) {
676− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2))
677− return;
678−
679− for (int i = 0; i < (m_iStrideA << 5); i++)
680− m_pPixSrcA[i] = rand() % 256;
681− for (int i = 0; i < (m_iStrideB << 5); i++)
682− m_pPixSrcB[i] = rand() % 256;
683− uint8_t* pPixA = m_pPixSrcA;
684− uint8_t* pPixB = m_pPixSrcB + m_iStrideB;
685−
686− int32_t iSumSad = 0;
687− for (int i = 0; i < 16; i++) {
688− for (int j = 0; j < 16; j++) {
689− iSumSad += abs (pPixA[j] - pPixB[j - 1]);
690− iSumSad += abs (pPixA[j] - pPixB[j + 1]);
691− iSumSad += abs (pPixA[j] - pPixB[j - m_iStrideB]);
692− iSumSad += abs (pPixA[j] - pPixB[j + m_iStrideB]);
693− }
694−
695− pPixA += m_iStrideA;
696− pPixB += m_iStrideB;
697− }
698−
699− WelsSampleSadFour16x16_sse2 (m_pPixSrcA, m_iStrideA, m_pPixSrcB + m_iStrideB, m_iStrideB, m_pSad);
700− EXPECT_EQ (m_pSad[0] + m_pSad[1] + m_pSad[2] + m_pSad[3], iSumSad);
701−}
702−
703−TEST_F (SadSatdAssemblyFuncTest, WelsSampleSadFour16x8_sse2) {
704− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2))
705− return;
706−
707− for (int i = 0; i < (m_iStrideA << 5); i++)
708− m_pPixSrcA[i] = rand() % 256;
709− for (int i = 0; i < (m_iStrideB << 5); i++)
710− m_pPixSrcB[i] = rand() % 256;
711− uint8_t* pPixA = m_pPixSrcA;
712− uint8_t* pPixB = m_pPixSrcB + m_iStrideB;
713−
714− int32_t iSumSad = 0;
715− for (int i = 0; i < 8; i++) {
716− for (int j = 0; j < 16; j++) {
717− iSumSad += abs (pPixA[j] - pPixB[j - 1]);
718− iSumSad += abs (pPixA[j] - pPixB[j + 1]);
719− iSumSad += abs (pPixA[j] - pPixB[j - m_iStrideB]);
720− iSumSad += abs (pPixA[j] - pPixB[j + m_iStrideB]);
721− }
722−
723− pPixA += m_iStrideA;
724− pPixB += m_iStrideB;
725− }
726−
727− WelsSampleSadFour16x8_sse2 (m_pPixSrcA, m_iStrideA, m_pPixSrcB + m_iStrideB, m_iStrideB, m_pSad);
728− EXPECT_EQ (m_pSad[0] + m_pSad[1] + m_pSad[2] + m_pSad[3], iSumSad);
729−}
730−
731−TEST_F (SadSatdAssemblyFuncTest, WelsSampleSadFour8x16_sse2) {
732− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2))
733− return;
734−
735− for (int i = 0; i < (m_iStrideA << 5); i++)
736− m_pPixSrcA[i] = rand() % 256;
737− for (int i = 0; i < (m_iStrideB << 5); i++)
738− m_pPixSrcB[i] = rand() % 256;
739− uint8_t* pPixA = m_pPixSrcA;
740− uint8_t* pPixB = m_pPixSrcB + m_iStrideB;
741−
742− int32_t iSumSad = 0;
743− for (int i = 0; i < 16; i++) {
744− for (int j = 0; j < 8; j++) {
745− iSumSad += abs (pPixA[j] - pPixB[j - 1]);
746− iSumSad += abs (pPixA[j] - pPixB[j + 1]);
747− iSumSad += abs (pPixA[j] - pPixB[j - m_iStrideB]);
748− iSumSad += abs (pPixA[j] - pPixB[j + m_iStrideB]);
749− }
750−
751− pPixA += m_iStrideA;
752− pPixB += m_iStrideB;
753− }
754−
755− WelsSampleSadFour8x16_sse2 (m_pPixSrcA, m_iStrideA, m_pPixSrcB + m_iStrideB, m_iStrideB, m_pSad);
756− EXPECT_EQ (m_pSad[0] + m_pSad[1] + m_pSad[2] + m_pSad[3], iSumSad);
479+#define GENERATE_Sad4x4_UT(func, ref, CPUFLAGS) \
480+TEST_F (SadSatdAssemblyFuncTest, func) { \
481+ if (0 == (m_uiCpuFeatureFlag & CPUFLAGS)) \
482+ return; \
483+ for (int i = 0; i < (m_iStrideA << 2); i++) \
484+ m_pPixSrcA[i] = rand() % 256; \
485+ for (int i = 0; i < (m_iStrideB << 2); i++) \
486+ m_pPixSrcB[i] = rand() % 256; \
487+ EXPECT_EQ (ref (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), func (m_pPixSrcA, \
488+ m_iStrideA, m_pPixSrcB, m_iStrideB)); \
489+}
490+
491+#define GENERATE_Sad8x8_UT(func, ref, CPUFLAGS) \
492+TEST_F (SadSatdAssemblyFuncTest, func) { \
493+ if (0 == (m_uiCpuFeatureFlag & CPUFLAGS)) \
494+ return; \
495+ for (int i = 0; i < (m_iStrideA << 3); i++) \
496+ m_pPixSrcA[i] = rand() % 256; \
497+ for (int i = 0; i < (m_iStrideB << 3); i++) \
498+ m_pPixSrcB[i] = rand() % 256; \
499+ EXPECT_EQ (ref (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), func (m_pPixSrcA, \
500+ m_iStrideA, m_pPixSrcB, m_iStrideB)); \
501+}
502+
503+#define GENERATE_Sad8x16_UT(func, ref, CPUFLAGS) \
504+TEST_F (SadSatdAssemblyFuncTest, func) { \
505+ if (0 == (m_uiCpuFeatureFlag & CPUFLAGS)) \
506+ return; \
507+ for (int i = 0; i < (m_iStrideA << 4); i++) \
508+ m_pPixSrcA[i] = rand() % 256; \
509+ for (int i = 0; i < (m_iStrideB << 4); i++) \
510+ m_pPixSrcB[i] = rand() % 256; \
511+ EXPECT_EQ (ref (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), func (m_pPixSrcA, \
512+ m_iStrideA, m_pPixSrcB, m_iStrideB)); \
513+}
514+
515+#define GENERATE_Sad16x8_UT(func, ref, CPUFLAGS) \
516+TEST_F (SadSatdAssemblyFuncTest, func) { \
517+ if (0 == (m_uiCpuFeatureFlag & CPUFLAGS)) \
518+ return; \
519+ for (int i = 0; i < (m_iStrideA << 3); i++) \
520+ m_pPixSrcA[i] = rand() % 256; \
521+ for (int i = 0; i < (m_iStrideB << 3); i++) \
522+ m_pPixSrcB[i] = rand() % 256; \
523+ EXPECT_EQ (ref (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), func (m_pPixSrcA, \
524+ m_iStrideA, m_pPixSrcB, m_iStrideB)); \
525+}
526+
527+#define GENERATE_Sad16x16_UT(func, ref, CPUFLAGS) \
528+TEST_F (SadSatdAssemblyFuncTest, func) { \
529+ if (0 == (m_uiCpuFeatureFlag & CPUFLAGS)) \
530+ return; \
531+ for (int i = 0; i < (m_iStrideA << 4); i++) \
532+ m_pPixSrcA[i] = rand() % 256; \
533+ for (int i = 0; i < (m_iStrideB << 4); i++) \
534+ m_pPixSrcB[i] = rand() % 256; \
535+ EXPECT_EQ (ref (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), func (m_pPixSrcA, \
536+ m_iStrideA, m_pPixSrcB, m_iStrideB)); \
757537 }
758538
759−TEST_F (SadSatdAssemblyFuncTest, WelsSampleSadFour8x8_sse2) {
760− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2))
761− return;
762−
763− for (int i = 0; i < (m_iStrideA << 4); i++)
764− m_pPixSrcA[i] = rand() % 256;
765− for (int i = 0; i < (m_iStrideB << 4); i++)
766− m_pPixSrcB[i] = rand() % 256;
767− uint8_t* pPixA = m_pPixSrcA;
768− uint8_t* pPixB = m_pPixSrcB + m_iStrideB;
539+#ifdef X86_ASM
540+GENERATE_Sad4x4_UT(WelsSampleSad4x4_mmx, WelsSampleSad4x4_c, WELS_CPU_MMXEXT)
541+GENERATE_Sad8x8_UT(WelsSampleSad8x8_sse21, WelsSampleSad8x8_c, WELS_CPU_SSE2)
542+GENERATE_Sad8x16_UT(WelsSampleSad8x16_sse2, WelsSampleSad8x16_c, WELS_CPU_SSE2)
543+GENERATE_Sad16x8_UT(WelsSampleSad16x8_sse2, WelsSampleSad16x8_c, WELS_CPU_SSE2)
544+GENERATE_Sad16x16_UT(WelsSampleSad16x16_sse2, WelsSampleSad16x16_c, WELS_CPU_SSE2)
545+
546+GENERATE_Sad4x4_UT(WelsSampleSatd4x4_sse2, WelsSampleSatd4x4_c, WELS_CPU_SSE2)
547+GENERATE_Sad8x8_UT(WelsSampleSatd8x8_sse2, WelsSampleSatd8x8_c, WELS_CPU_SSE2)
548+GENERATE_Sad8x16_UT(WelsSampleSatd8x16_sse2, WelsSampleSatd8x16_c, WELS_CPU_SSE2)
549+GENERATE_Sad16x8_UT(WelsSampleSatd16x8_sse2, WelsSampleSatd16x8_c, WELS_CPU_SSE2)
550+GENERATE_Sad16x16_UT(WelsSampleSatd16x16_sse2, WelsSampleSatd16x16_c, WELS_CPU_SSE2)
551+
552+GENERATE_Sad4x4_UT(WelsSampleSatd4x4_sse41, WelsSampleSatd4x4_c, WELS_CPU_SSE41)
553+GENERATE_Sad8x8_UT(WelsSampleSatd8x8_sse41, WelsSampleSatd8x8_c, WELS_CPU_SSE41)
554+GENERATE_Sad8x16_UT(WelsSampleSatd8x16_sse41, WelsSampleSatd8x16_c, WELS_CPU_SSE41)
555+GENERATE_Sad16x8_UT(WelsSampleSatd16x8_sse41, WelsSampleSatd16x8_c, WELS_CPU_SSE41)
556+GENERATE_Sad16x16_UT(WelsSampleSatd16x16_sse41, WelsSampleSatd16x16_c, WELS_CPU_SSE41)
557+#endif
769558
770− int32_t iSumSad = 0;
771− for (int i = 0; i < 8; i++) {
772− for (int j = 0; j < 8; j++) {
773− iSumSad += abs (pPixA[j] - pPixB[j - 1]);
774− iSumSad += abs (pPixA[j] - pPixB[j + 1]);
775− iSumSad += abs (pPixA[j] - pPixB[j - m_iStrideB]);
776− iSumSad += abs (pPixA[j] - pPixB[j + m_iStrideB]);
777− }
559+#ifdef HAVE_NEON
560+GENERATE_Sad4x4_UT(WelsSampleSad4x4_neon, WelsSampleSad4x4_c, WELS_CPU_NEON)
561+GENERATE_Sad8x8_UT(WelsSampleSad8x8_neon, WelsSampleSad8x8_c, WELS_CPU_NEON)
562+GENERATE_Sad8x16_UT(WelsSampleSad8x16_neon, WelsSampleSad8x16_c, WELS_CPU_NEON)
563+GENERATE_Sad16x8_UT(WelsSampleSad16x8_neon, WelsSampleSad16x8_c, WELS_CPU_NEON)
564+GENERATE_Sad16x16_UT(WelsSampleSad16x16_neon, WelsSampleSad16x16_c, WELS_CPU_NEON)
565+
566+GENERATE_Sad4x4_UT(WelsSampleSatd4x4_neon, WelsSampleSatd4x4_c, WELS_CPU_NEON)
567+GENERATE_Sad8x8_UT(WelsSampleSatd8x8_neon, WelsSampleSatd8x8_c, WELS_CPU_NEON)
568+GENERATE_Sad8x16_UT(WelsSampleSatd8x16_neon, WelsSampleSatd8x16_c, WELS_CPU_NEON)
569+GENERATE_Sad16x8_UT(WelsSampleSatd16x8_neon, WelsSampleSatd16x8_c, WELS_CPU_NEON)
570+GENERATE_Sad16x16_UT(WelsSampleSatd16x16_neon, WelsSampleSatd16x16_c, WELS_CPU_NEON)
571+#endif
778572
779− pPixA += m_iStrideA;
780− pPixB += m_iStrideB;
781− }
573+#ifdef HAVE_NEON_AARCH64
574+GENERATE_Sad4x4_UT(WelsSampleSad4x4_AArch64_neon, WelsSampleSad4x4_c, WELS_CPU_NEON)
575+GENERATE_Sad8x8_UT(WelsSampleSad8x8_AArch64_neon, WelsSampleSad8x8_c, WELS_CPU_NEON)
576+GENERATE_Sad8x16_UT(WelsSampleSad8x16_AArch64_neon, WelsSampleSad8x16_c, WELS_CPU_NEON)
577+GENERATE_Sad16x8_UT(WelsSampleSad16x8_AArch64_neon, WelsSampleSad16x8_c, WELS_CPU_NEON)
578+GENERATE_Sad16x16_UT(WelsSampleSad16x16_AArch64_neon, WelsSampleSad16x16_c, WELS_CPU_NEON)
579+
580+GENERATE_Sad4x4_UT(WelsSampleSatd4x4_AArch64_neon, WelsSampleSatd4x4_c, WELS_CPU_NEON)
581+GENERATE_Sad8x8_UT(WelsSampleSatd8x8_AArch64_neon, WelsSampleSatd8x8_c, WELS_CPU_NEON)
582+GENERATE_Sad8x16_UT(WelsSampleSatd8x16_AArch64_neon, WelsSampleSatd8x16_c, WELS_CPU_NEON)
583+GENERATE_Sad16x8_UT(WelsSampleSatd16x8_AArch64_neon, WelsSampleSatd16x8_c, WELS_CPU_NEON)
584+GENERATE_Sad16x16_UT(WelsSampleSatd16x16_AArch64_neon, WelsSampleSatd16x16_c, WELS_CPU_NEON)
585+#endif
782586
783− WelsSampleSadFour8x8_sse2 (m_pPixSrcA, m_iStrideA, m_pPixSrcB + m_iStrideB, m_iStrideB, m_pSad);
784− EXPECT_EQ (m_pSad[0] + m_pSad[1] + m_pSad[2] + m_pSad[3], iSumSad);
587+#define GENERATE_SadFour_UT(func, CPUFLAGS, width, height) \
588+TEST_F (SadSatdAssemblyFuncTest, func) { \
589+ if (0 == (m_uiCpuFeatureFlag & CPUFLAGS)) \
590+ return; \
591+ for (int i = 0; i < (m_iStrideA << 5); i++) \
592+ m_pPixSrcA[i] = rand() % 256; \
593+ for (int i = 0; i < (m_iStrideB << 5); i++) \
594+ m_pPixSrcB[i] = rand() % 256; \
595+ uint8_t* pPixA = m_pPixSrcA; \
596+ uint8_t* pPixB = m_pPixSrcB + m_iStrideB; \
597+ int32_t iSumSad = 0; \
598+ for (int i = 0; i < height; i++) { \
599+ for (int j = 0; j < width; j++) { \
600+ iSumSad += abs (pPixA[j] - pPixB[j - 1]); \
601+ iSumSad += abs (pPixA[j] - pPixB[j + 1]); \
602+ iSumSad += abs (pPixA[j] - pPixB[j - m_iStrideB]); \
603+ iSumSad += abs (pPixA[j] - pPixB[j + m_iStrideB]); \
604+ } \
605+ pPixA += m_iStrideA; \
606+ pPixB += m_iStrideB; \
607+ } \
608+ func (m_pPixSrcA, m_iStrideA, m_pPixSrcB + m_iStrideB, m_iStrideB, m_pSad); \
609+ EXPECT_EQ (m_pSad[0] + m_pSad[1] + m_pSad[2] + m_pSad[3], iSumSad); \
785610 }
786611
612+#ifdef X86_ASM
613+GENERATE_SadFour_UT(WelsSampleSadFour4x4_sse2, WELS_CPU_SSE2, 4, 4)
614+GENERATE_SadFour_UT(WelsSampleSadFour8x8_sse2, WELS_CPU_SSE2, 8, 8)
615+GENERATE_SadFour_UT(WelsSampleSadFour8x16_sse2, WELS_CPU_SSE2, 8, 16)
616+GENERATE_SadFour_UT(WelsSampleSadFour16x8_sse2, WELS_CPU_SSE2, 16, 8)
617+GENERATE_SadFour_UT(WelsSampleSadFour16x16_sse2, WELS_CPU_SSE2, 16, 16)
618+#endif
787619
788−TEST_F (SadSatdAssemblyFuncTest, WelsSampleSadFour4x4_sse2) {
789− if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2))
790− return;
791−
792− for (int i = 0; i < (m_iStrideA << 3); i++)
793− m_pPixSrcA[i] = rand() % 256;
794− for (int i = 0; i < (m_iStrideB << 3); i++)
795− m_pPixSrcB[i] = rand() % 256;
796− uint8_t* pPixA = m_pPixSrcA;
797− uint8_t* pPixB = m_pPixSrcB + m_iStrideB;
798−
799− int32_t iSumSad = 0;
800− for (int i = 0; i < 4; i++) {
801− for (int j = 0; j < 4; j++) {
802− iSumSad += abs (pPixA[j] - pPixB[j - 1]);
803− iSumSad += abs (pPixA[j] - pPixB[j + 1]);
804− iSumSad += abs (pPixA[j] - pPixB[j - m_iStrideB]);
805− iSumSad += abs (pPixA[j] - pPixB[j + m_iStrideB]);
806− }
807−
808− pPixA += m_iStrideA;
809− pPixB += m_iStrideB;
810− }
811−
812− WelsSampleSadFour4x4_sse2 (m_pPixSrcA, m_iStrideA, m_pPixSrcB + m_iStrideB, m_iStrideB, m_pSad);
813− EXPECT_EQ (m_pSad[0] + m_pSad[1] + m_pSad[2] + m_pSad[3], iSumSad);
814−}
620+#ifdef HAVE_NEON
621+GENERATE_SadFour_UT(WelsSampleSadFour4x4_neon, WELS_CPU_NEON, 4, 4)
622+GENERATE_SadFour_UT(WelsSampleSadFour8x8_neon, WELS_CPU_NEON, 8, 8)
623+GENERATE_SadFour_UT(WelsSampleSadFour8x16_neon, WELS_CPU_NEON, 8, 16)
624+GENERATE_SadFour_UT(WelsSampleSadFour16x8_neon, WELS_CPU_NEON, 16, 8)
625+GENERATE_SadFour_UT(WelsSampleSadFour16x16_neon, WELS_CPU_NEON, 16, 16)
815626 #endif
627+
628+#ifdef HAVE_NEON_AARCH64
629+GENERATE_SadFour_UT(WelsSampleSadFour4x4_AArch64_neon, WELS_CPU_NEON, 4, 4)
630+GENERATE_SadFour_UT(WelsSampleSadFour8x8_AArch64_neon, WELS_CPU_NEON, 8, 8)
631+GENERATE_SadFour_UT(WelsSampleSadFour8x16_AArch64_neon, WELS_CPU_NEON, 8, 16)
632+GENERATE_SadFour_UT(WelsSampleSadFour16x8_AArch64_neon, WELS_CPU_NEON, 16, 8)
633+GENERATE_SadFour_UT(WelsSampleSadFour16x16_AArch64_neon, WELS_CPU_NEON, 16, 16)
634+#endif

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t