Showing the changes to test/encoder/EncUT_Sample.cpp (1 of 3 files). Show all
Unified · Split
| @@ -8,136 +8,123 @@ · 7 unmodified lines | |||
| 8 | #include "get_intra_predictor.h" | 8 | #include "get_intra_predictor.h" |
| 9 | 9 | ||
| 10 | using namespace WelsEnc; | 10 | 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 | } | ||
| 42 | 11 | ||
| 43 | TEST (IntraSadSatdFuncTest, WelsIntra16x16Combined3Satd_sse41) { | 12 | #define GENERATE_Intra16x16_UT(func, ref, ASM, CPUFLAGS) \ |
| 44 | const int32_t iLineSizeDec = 32; | 13 | TEST (IntraSadSatdFuncTest, func) { \ |
| 45 | const int32_t iLineSizeEnc = 32; | 14 | const int32_t iLineSizeDec = 32; \ |
| 46 | int32_t tmpa, tmpb; | 15 | const int32_t iLineSizeEnc = 32; \ |
| 47 | int32_t iBestMode_c, iBestMode_a, iLambda = 50; | 16 | int32_t tmpa, tmpb; \ |
| 48 | CMemoryAlign cMemoryAlign (0); | 17 | int32_t iBestMode_c, iBestMode_a, iLambda = 50; \ |
| 49 | int32_t iCpuCores = 0; | 18 | if (ASM) {\ |
| 50 | uint32_t m_uiCpuFeatureFlag = WelsCPUFeatureDetect (&iCpuCores); | 19 | int32_t iCpuCores = 0; \ |
| 51 | if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE41)) | 20 | uint32_t m_uiCpuFeatureFlag = WelsCPUFeatureDetect (&iCpuCores); \ |
| 52 | return; | 21 | if (0 == (m_uiCpuFeatureFlag & CPUFLAGS)) \ |
| 53 | uint8_t* pDec = (uint8_t*)cMemoryAlign.WelsMalloc (iLineSizeDec << 5, "pDec"); | 22 | return; \ |
| 54 | uint8_t* pEnc = (uint8_t*)cMemoryAlign.WelsMalloc (iLineSizeEnc << 5, "pEnc"); | 23 | } \ |
| 55 | uint8_t* pDst = (uint8_t*)cMemoryAlign.WelsMalloc (512, "pDst"); | 24 | ENFORCE_STACK_ALIGN_1D (uint8_t, pDec, iLineSizeDec << 5, 16); \ |
| 56 | for (int i = 0; i < (iLineSizeDec << 5); i++) | 25 | ENFORCE_STACK_ALIGN_1D (uint8_t, pEnc, iLineSizeEnc << 5, 16); \ |
| 57 | pDec[i] = rand() % 256; | 26 | ENFORCE_STACK_ALIGN_1D (uint8_t, pDst, 512, 16); \ |
| 58 | for (int i = 0; i < (iLineSizeEnc << 5); i++) | 27 | for (int i = 0; i < (iLineSizeDec << 5); i++) \ |
| 59 | pEnc[i] = rand() % 256; | 28 | pDec[i] = rand() % 256; \ |
| 60 | for (int i = 0; i < 512; i++) | 29 | for (int i = 0; i < (iLineSizeEnc << 5); i++) \ |
| 61 | pDst[i] = rand() % 256; | 30 | pEnc[i] = rand() % 256; \ |
| 62 | tmpa = WelsSampleSatdIntra16x16Combined3_c (pDec + 128, iLineSizeDec, pEnc, iLineSizeEnc, &iBestMode_c, iLambda, pDst); | 31 | for (int i = 0; i < 512; i++) \ |
| 63 | tmpb = WelsIntra16x16Combined3Satd_sse41 (pDec + 128, iLineSizeDec, pEnc, iLineSizeEnc, &iBestMode_a, iLambda, pDst); | 32 | pDst[i] = rand() % 256; \ |
| 64 | ASSERT_EQ (tmpa, tmpb); | 33 | tmpa = ref (pDec + 128, iLineSizeDec, pEnc, iLineSizeEnc, &iBestMode_c, iLambda, pDst); \ |
| 65 | ASSERT_EQ (iBestMode_c, iBestMode_a); | 34 | tmpb = func (pDec + 128, iLineSizeDec, pEnc, iLineSizeEnc, &iBestMode_a, iLambda, pDst); \ |
| 66 | cMemoryAlign.WelsFree (pDec, "pDec"); | 35 | ASSERT_EQ (tmpa, tmpb); \ |
| 67 | cMemoryAlign.WelsFree (pEnc, "pEnc"); | 36 | ASSERT_EQ (iBestMode_c, iBestMode_a); \ |
| 68 | cMemoryAlign.WelsFree (pDst, "pDst"); | 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); \ | ||
| 69 | } | 103 | } |
| 70 | 104 | ||
| 71 | TEST (IntraSadSatdFuncTest, WelsSampleSatdThree4x4_sse2) { | 105 | #ifdef X86_ASM |
| 72 | const int32_t iLineSizeDec = 32; | 106 | GENERATE_Intra16x16_UT(WelsIntra16x16Combined3Sad_ssse3, WelsSampleSadIntra16x16Combined3_c, 1, WELS_CPU_SSSE3) |
| 73 | const int32_t iLineSizeEnc = 32; | 107 | GENERATE_Intra16x16_UT(WelsIntra16x16Combined3Satd_sse41, WelsSampleSatdIntra16x16Combined3_c, 1, WELS_CPU_SSE41) |
| 74 | int32_t tmpa, tmpb; | 108 | GENERATE_Intra8x8_UT(WelsIntraChroma8x8Combined3Satd_sse41, WelsSampleSatdIntra8x8Combined3_c, 1, WELS_CPU_SSE41) |
| 75 | int32_t iBestMode_c, iBestMode_a, iLambda = 50; | 109 | GENERATE_Intra4x4_UT(WelsSampleSatdThree4x4_sse2, 1, WELS_CPU_SSE2) |
| 76 | int32_t lambda[2] = {iLambda << 2, iLambda}; | 110 | #endif |
| 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 | } | ||
| 102 | 111 | ||
| 103 | TEST (IntraSadSatdFuncTest, WelsIntraChroma8x8Combined3Satd_sse41) { | 112 | #ifdef HAVE_NEON |
| 104 | const int32_t iLineSizeDec = 32; | 113 | GENERATE_Intra16x16_UT(WelsIntra16x16Combined3Sad_neon, WelsSampleSadIntra16x16Combined3_c, 1, WELS_CPU_NEON) |
| 105 | const int32_t iLineSizeEnc = 32; | 114 | GENERATE_Intra16x16_UT(WelsIntra16x16Combined3Satd_neon, WelsSampleSatdIntra16x16Combined3_c, 1, WELS_CPU_NEON) |
| 106 | int32_t tmpa, tmpb; | 115 | GENERATE_Intra8x8_UT(WelsIntra8x8Combined3Satd_neon, WelsSampleSatdIntra8x8Combined3_c, 1, WELS_CPU_NEON) |
| 107 | int32_t iBestMode_c, iBestMode_a, iLambda = 50; | 116 | GENERATE_Intra8x8_UT(WelsIntra8x8Combined3Sad_neon, WelsSampleSadIntra8x8Combined3_c, 1, WELS_CPU_NEON) |
| 108 | CMemoryAlign cMemoryAlign (0); | 117 | GENERATE_Intra4x4_UT(WelsIntra4x4Combined3Satd_neon, 1, WELS_CPU_NEON) |
| 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 | } | ||
| 140 | #endif | 118 | #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 | |||
| 141 | #define ASSERT_MEMORY_FAIL2X(A, B) \ | 128 | #define ASSERT_MEMORY_FAIL2X(A, B) \ |
| 142 | if (NULL == B) { \ | 129 | if (NULL == B) { \ |
| 143 | pMemAlign->WelsFree(A, "Sad_SrcA");\ | 130 | pMemAlign->WelsFree(A, "Sad_SrcA");\ |
| @@ -457,7 +444,7 @@ TEST_F (SadSatdCFuncTest, WelsSampleSadFour4x4_c) { · 313 unmodified lines | |||
| 457 | EXPECT_EQ (m_pSad[0] + m_pSad[1] + m_pSad[2] + m_pSad[3], iSumSad); | 444 | EXPECT_EQ (m_pSad[0] + m_pSad[1] + m_pSad[2] + m_pSad[3], iSumSad); |
| 458 | } | 445 | } |
| 459 | 446 | ||
| 460 | #ifdef X86_ASM | 447 | |
| 461 | class SadSatdAssemblyFuncTest : public testing::Test { | 448 | class SadSatdAssemblyFuncTest : public testing::Test { |
| 462 | public: | 449 | public: |
| 463 | virtual void SetUp() { | 450 | virtual void SetUp() { |
| @@ -489,327 +476,159 @@ class SadSatdAssemblyFuncTest : public testing::Test { · 25 unmodified lines | |||
| 489 | CMemoryAlign* pMemAlign; | 476 | CMemoryAlign* pMemAlign; |
| 490 | }; | 477 | }; |
| 491 | 478 | ||
| 492 | TEST_F (SadSatdAssemblyFuncTest, WelsSampleSad4x4_mmx) { | 479 | #define GENERATE_Sad4x4_UT(func, ref, CPUFLAGS) \ |
| 493 | if (0 == (m_uiCpuFeatureFlag & WELS_CPU_MMXEXT)) | 480 | TEST_F (SadSatdAssemblyFuncTest, func) { \ |
| 494 | return; | 481 | if (0 == (m_uiCpuFeatureFlag & CPUFLAGS)) \ |
| 495 | 482 | return; \ | |
| 496 | for (int i = 0; i < (m_iStrideA << 2); i++) | 483 | for (int i = 0; i < (m_iStrideA << 2); i++) \ |
| 497 | m_pPixSrcA[i] = rand() % 256; | 484 | m_pPixSrcA[i] = rand() % 256; \ |
| 498 | for (int i = 0; i < (m_iStrideB << 2); i++) | 485 | for (int i = 0; i < (m_iStrideB << 2); i++) \ |
| 499 | m_pPixSrcB[i] = rand() % 256; | 486 | m_pPixSrcB[i] = rand() % 256; \ |
| 500 | 487 | EXPECT_EQ (ref (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), func (m_pPixSrcA, \ | |
| 501 | EXPECT_EQ (WelsSampleSad4x4_c (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), WelsSampleSad4x4_mmx (m_pPixSrcA, | 488 | m_iStrideA, m_pPixSrcB, m_iStrideB)); \ |
| 502 | m_iStrideA, m_pPixSrcB, m_iStrideB)); | 489 | } |
| 503 | } | 490 | |
| 504 | 491 | #define GENERATE_Sad8x8_UT(func, ref, CPUFLAGS) \ | |
| 505 | 492 | TEST_F (SadSatdAssemblyFuncTest, func) { \ | |
| 506 | TEST_F (SadSatdAssemblyFuncTest, WelsSampleSad8x8_sse21) { | 493 | if (0 == (m_uiCpuFeatureFlag & CPUFLAGS)) \ |
| 507 | if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2)) | 494 | return; \ |
| 508 | return; | 495 | for (int i = 0; i < (m_iStrideA << 3); i++) \ |
| 509 | 496 | m_pPixSrcA[i] = rand() % 256; \ | |
| 510 | for (int i = 0; i < (m_iStrideA << 3); i++) | 497 | for (int i = 0; i < (m_iStrideB << 3); i++) \ |
| 511 | m_pPixSrcA[i] = rand() % 256; | 498 | m_pPixSrcB[i] = rand() % 256; \ |
| 512 | for (int i = 0; i < (m_iStrideB << 3); i++) | 499 | EXPECT_EQ (ref (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), func (m_pPixSrcA, \ |
| 513 | m_pPixSrcB[i] = rand() % 256; | 500 | m_iStrideA, m_pPixSrcB, m_iStrideB)); \ |
| 514 | 501 | } | |
| 515 | EXPECT_EQ (WelsSampleSad8x8_c (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), WelsSampleSad8x8_sse21 (m_pPixSrcA, | 502 | |
| 516 | m_iStrideA, m_pPixSrcB, m_iStrideB)); | 503 | #define GENERATE_Sad8x16_UT(func, ref, CPUFLAGS) \ |
| 517 | } | 504 | TEST_F (SadSatdAssemblyFuncTest, func) { \ |
| 518 | 505 | if (0 == (m_uiCpuFeatureFlag & CPUFLAGS)) \ | |
| 519 | TEST_F (SadSatdAssemblyFuncTest, WelsSampleSad8x16_sse2) { | 506 | return; \ |
| 520 | if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2)) | 507 | for (int i = 0; i < (m_iStrideA << 4); i++) \ |
| 521 | return; | 508 | m_pPixSrcA[i] = rand() % 256; \ |
| 522 | for (int i = 0; i < (m_iStrideA << 4); i++) | 509 | for (int i = 0; i < (m_iStrideB << 4); i++) \ |
| 523 | m_pPixSrcA[i] = rand() % 256; | 510 | m_pPixSrcB[i] = rand() % 256; \ |
| 524 | for (int i = 0; i < (m_iStrideB << 4); i++) | 511 | EXPECT_EQ (ref (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), func (m_pPixSrcA, \ |
| 525 | m_pPixSrcB[i] = rand() % 256; | 512 | m_iStrideA, m_pPixSrcB, m_iStrideB)); \ |
| 526 | 513 | } | |
| 527 | EXPECT_EQ (WelsSampleSad8x16_c (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), WelsSampleSad8x16_sse2 (m_pPixSrcA, | 514 | |
| 528 | m_iStrideA, m_pPixSrcB, m_iStrideB)); | 515 | #define GENERATE_Sad16x8_UT(func, ref, CPUFLAGS) \ |
| 529 | } | 516 | TEST_F (SadSatdAssemblyFuncTest, func) { \ |
| 530 | 517 | if (0 == (m_uiCpuFeatureFlag & CPUFLAGS)) \ | |
| 531 | TEST_F (SadSatdAssemblyFuncTest, WelsSampleSad16x8_sse2) { | 518 | return; \ |
| 532 | if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2)) | 519 | for (int i = 0; i < (m_iStrideA << 3); i++) \ |
| 533 | return; | 520 | m_pPixSrcA[i] = rand() % 256; \ |
| 534 | for (int i = 0; i < (m_iStrideA << 3); i++) | 521 | for (int i = 0; i < (m_iStrideB << 3); i++) \ |
| 535 | m_pPixSrcA[i] = rand() % 256; | 522 | m_pPixSrcB[i] = rand() % 256; \ |
| 536 | for (int i = 0; i < (m_iStrideB << 3); i++) | 523 | EXPECT_EQ (ref (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), func (m_pPixSrcA, \ |
| 537 | m_pPixSrcB[i] = rand() % 256; | 524 | m_iStrideA, m_pPixSrcB, m_iStrideB)); \ |
| 538 | 525 | } | |
| 539 | EXPECT_EQ (WelsSampleSad16x8_c (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), WelsSampleSad16x8_sse2 (m_pPixSrcA, | 526 | |
| 540 | m_iStrideA, m_pPixSrcB, m_iStrideB)); | 527 | #define GENERATE_Sad16x16_UT(func, ref, CPUFLAGS) \ |
| 541 | } | 528 | TEST_F (SadSatdAssemblyFuncTest, func) { \ |
| 542 | 529 | if (0 == (m_uiCpuFeatureFlag & CPUFLAGS)) \ | |
| 543 | TEST_F (SadSatdAssemblyFuncTest, WelsSampleSad16x16_sse2) { | 530 | return; \ |
| 544 | if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2)) | 531 | for (int i = 0; i < (m_iStrideA << 4); i++) \ |
| 545 | return; | 532 | m_pPixSrcA[i] = rand() % 256; \ |
| 546 | for (int i = 0; i < (m_iStrideA << 4); i++) | 533 | for (int i = 0; i < (m_iStrideB << 4); i++) \ |
| 547 | m_pPixSrcA[i] = rand() % 256; | 534 | m_pPixSrcB[i] = rand() % 256; \ |
| 548 | for (int i = 0; i < (m_iStrideB << 4); i++) | 535 | EXPECT_EQ (ref (m_pPixSrcA, m_iStrideA, m_pPixSrcB, m_iStrideB), func (m_pPixSrcA, \ |
| 549 | m_pPixSrcB[i] = rand() % 256; | 536 | m_iStrideA, m_pPixSrcB, m_iStrideB)); \ |
| 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); | ||
| 757 | } | 537 | } |
| 758 | 538 | ||
| 759 | TEST_F (SadSatdAssemblyFuncTest, WelsSampleSadFour8x8_sse2) { | 539 | #ifdef X86_ASM |
| 760 | if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2)) | 540 | GENERATE_Sad4x4_UT(WelsSampleSad4x4_mmx, WelsSampleSad4x4_c, WELS_CPU_MMXEXT) |
| 761 | return; | 541 | GENERATE_Sad8x8_UT(WelsSampleSad8x8_sse21, WelsSampleSad8x8_c, WELS_CPU_SSE2) |
| 762 | 542 | GENERATE_Sad8x16_UT(WelsSampleSad8x16_sse2, WelsSampleSad8x16_c, WELS_CPU_SSE2) | |
| 763 | for (int i = 0; i < (m_iStrideA << 4); i++) | 543 | GENERATE_Sad16x8_UT(WelsSampleSad16x8_sse2, WelsSampleSad16x8_c, WELS_CPU_SSE2) |
| 764 | m_pPixSrcA[i] = rand() % 256; | 544 | GENERATE_Sad16x16_UT(WelsSampleSad16x16_sse2, WelsSampleSad16x16_c, WELS_CPU_SSE2) |
| 765 | for (int i = 0; i < (m_iStrideB << 4); i++) | 545 | |
| 766 | m_pPixSrcB[i] = rand() % 256; | 546 | GENERATE_Sad4x4_UT(WelsSampleSatd4x4_sse2, WelsSampleSatd4x4_c, WELS_CPU_SSE2) |
| 767 | uint8_t* pPixA = m_pPixSrcA; | 547 | GENERATE_Sad8x8_UT(WelsSampleSatd8x8_sse2, WelsSampleSatd8x8_c, WELS_CPU_SSE2) |
| 768 | uint8_t* pPixB = m_pPixSrcB + m_iStrideB; | 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 | ||
| 769 | 558 | ||
| 770 | int32_t iSumSad = 0; | 559 | #ifdef HAVE_NEON |
| 771 | for (int i = 0; i < 8; i++) { | 560 | GENERATE_Sad4x4_UT(WelsSampleSad4x4_neon, WelsSampleSad4x4_c, WELS_CPU_NEON) |
| 772 | for (int j = 0; j < 8; j++) { | 561 | GENERATE_Sad8x8_UT(WelsSampleSad8x8_neon, WelsSampleSad8x8_c, WELS_CPU_NEON) |
| 773 | iSumSad += abs (pPixA[j] - pPixB[j - 1]); | 562 | GENERATE_Sad8x16_UT(WelsSampleSad8x16_neon, WelsSampleSad8x16_c, WELS_CPU_NEON) |
| 774 | iSumSad += abs (pPixA[j] - pPixB[j + 1]); | 563 | GENERATE_Sad16x8_UT(WelsSampleSad16x8_neon, WelsSampleSad16x8_c, WELS_CPU_NEON) |
| 775 | iSumSad += abs (pPixA[j] - pPixB[j - m_iStrideB]); | 564 | GENERATE_Sad16x16_UT(WelsSampleSad16x16_neon, WelsSampleSad16x16_c, WELS_CPU_NEON) |
| 776 | iSumSad += abs (pPixA[j] - pPixB[j + m_iStrideB]); | 565 | |
| 777 | } | 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 | ||
| 778 | 572 | ||
| 779 | pPixA += m_iStrideA; | 573 | #ifdef HAVE_NEON_AARCH64 |
| 780 | pPixB += m_iStrideB; | 574 | GENERATE_Sad4x4_UT(WelsSampleSad4x4_AArch64_neon, WelsSampleSad4x4_c, WELS_CPU_NEON) |
| 781 | } | 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 | ||
| 782 | 586 | ||
| 783 | WelsSampleSadFour8x8_sse2 (m_pPixSrcA, m_iStrideA, m_pPixSrcB + m_iStrideB, m_iStrideB, m_pSad); | 587 | #define GENERATE_SadFour_UT(func, CPUFLAGS, width, height) \ |
| 784 | EXPECT_EQ (m_pSad[0] + m_pSad[1] + m_pSad[2] + m_pSad[3], iSumSad); | 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); \ | ||
| 785 | } | 610 | } |
| 786 | 611 | ||
| 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 | ||
| 787 | 619 | ||
| 788 | TEST_F (SadSatdAssemblyFuncTest, WelsSampleSadFour4x4_sse2) { | 620 | #ifdef HAVE_NEON |
| 789 | if (0 == (m_uiCpuFeatureFlag & WELS_CPU_SSE2)) | 621 | GENERATE_SadFour_UT(WelsSampleSadFour4x4_neon, WELS_CPU_NEON, 4, 4) |
| 790 | return; | 622 | GENERATE_SadFour_UT(WelsSampleSadFour8x8_neon, WELS_CPU_NEON, 8, 8) |
| 791 | 623 | GENERATE_SadFour_UT(WelsSampleSadFour8x16_neon, WELS_CPU_NEON, 8, 16) | |
| 792 | for (int i = 0; i < (m_iStrideA << 3); i++) | 624 | GENERATE_SadFour_UT(WelsSampleSadFour16x8_neon, WELS_CPU_NEON, 16, 8) |
| 793 | m_pPixSrcA[i] = rand() % 256; | 625 | GENERATE_SadFour_UT(WelsSampleSadFour16x16_neon, WELS_CPU_NEON, 16, 16) |
| 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 | } | ||
| 815 | #endif | 626 | #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 | ||