History

astyle all

huili2 committed 12 years ago

Commit dc3fae41 parent 101265385 files · +4906 −4701Browse files

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

Unified · Split

test/encoder/EncUT_GetIntraPredictor.cpp+242−243
@@ -7,40 +7,39 @@ · 6 unmodified lines
7 7
8using namespace WelsSVCEnc;8using namespace WelsSVCEnc;
9 9
10TEST(GetIntraPredictorTest, TestGetI4x4LumaPredV) {10TEST (GetIntraPredictorTest, TestGetI4x4LumaPredV) {
11 uint8_t *pPred = new uint8_t[64];11 uint8_t* pPred = new uint8_t[64];
12 uint8_t *pRef = new uint8_t[64];12 uint8_t* pRef = new uint8_t[64];
13 for (int i=0; i<64; i++)13 for (int i = 0; i < 64; i++)
14 pRef[i] = rand() % 256;14 pRef[i] = rand() % 256;
15 15
16 const int32_t kkiStride = 0;16 const int32_t kkiStride = 0;
17 const uint32_t kuiCpuFlag = 0;17 const uint32_t kuiCpuFlag = 0;
18 WelsInitFillingPredFuncs(kuiCpuFlag);18 WelsInitFillingPredFuncs (kuiCpuFlag);
19 WelsI4x4LumaPredV_c(pPred, pRef, kkiStride);19 WelsI4x4LumaPredV_c (pPred, pRef, kkiStride);
20 20
21 for (int i=0; i<4; i++)21 for (int i = 0; i < 4; i++)
22 EXPECT_EQ(LD32(&pPred[4*i]),LD32(&pRef[-kkiStride]));22 EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&pRef[-kkiStride]));
23 23
24 delete []pRef;24 delete []pRef;
25 delete []pPred;25 delete []pPred;
26}26}
27 27
28TEST(GetIntraPredictorTest, TestGetI4x4LumaPredH)28TEST (GetIntraPredictorTest, TestGetI4x4LumaPredH) {
29{29 const int32_t kiStride = rand() % 256 + 16;
30 const int32_t kiStride = rand()%256+16;30 const uint32_t kiStride2 = (kiStride << 1) - 1;
31 const uint32_t kiStride2 = (kiStride<<1)-1;
32 const uint32_t kiStride3 = kiStride + kiStride2;31 const uint32_t kiStride3 = kiStride + kiStride2;
33 32
34 uint8_t *pPred = new uint8_t[64];33 uint8_t* pPred = new uint8_t[64];
35 uint8_t *pRef = new uint8_t[kiStride3+2];34 uint8_t* pRef = new uint8_t[kiStride3 + 2];
36 35
37 for (int i=0; i<(static_cast<int32_t>(kiStride3+2)); i++)36 for (int i = 0; i < (static_cast<int32_t> (kiStride3 + 2)); i++)
38 pRef[i] = rand() % 256;37 pRef[i] = rand() % 256;
39 38
40 pRef++;39 pRef++;
41 40
42 const uint8_t kuiH1 = pRef[-1];41 const uint8_t kuiH1 = pRef[-1];
43 const uint8_t kuiH2 = pRef[kiStride-1];42 const uint8_t kuiH2 = pRef[kiStride - 1];
44 const uint8_t kuiH3 = pRef[kiStride2];43 const uint8_t kuiH3 = pRef[kiStride2];
45 const uint8_t kuiH4 = pRef[kiStride3];44 const uint8_t kuiH4 = pRef[kiStride3];
46 const uint8_t kuiV1[4] = {kuiH1, kuiH1, kuiH1, kuiH1};45 const uint8_t kuiV1[4] = {kuiH1, kuiH1, kuiH1, kuiH1};
@@ -50,17 +49,17 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredH) · 3 unmodified lines
50 49
51 const uint32_t kuiCpuFlag = 0;50 const uint32_t kuiCpuFlag = 0;
52 51
53 ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16)// TobeCont'd about assign opt as follows52 ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
54 ST32(&uiV[0], LD32(kuiV1));53 ST32 (&uiV[0], LD32 (kuiV1));
55 ST32(&uiV[4], LD32(kuiV2));54 ST32 (&uiV[4], LD32 (kuiV2));
56 ST32(&uiV[8], LD32(kuiV3));55 ST32 (&uiV[8], LD32 (kuiV3));
57 ST32(&uiV[12], LD32(kuiV4));56 ST32 (&uiV[12], LD32 (kuiV4));
58 57
59 WelsInitFillingPredFuncs(kuiCpuFlag);58 WelsInitFillingPredFuncs (kuiCpuFlag);
60 WelsI4x4LumaPredH_c(pPred, pRef, kiStride);59 WelsI4x4LumaPredH_c (pPred, pRef, kiStride);
61 60
62 for (int i=0; i<4; i++)61 for (int i = 0; i < 4; i++)
63 EXPECT_EQ(LD32(&pPred[4*i]), LD32(&uiV[4*i]));62 EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
64 63
65 pRef--;64 pRef--;
66 65
@@ -68,105 +67,105 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredH) · 1 unmodified line
68 delete []pPred;67 delete []pPred;
69}68}
70 69
71TEST(GetIntraPredictorTest, TestGetI4x4LumaPredDDL) {70TEST (GetIntraPredictorTest, TestGetI4x4LumaPredDDL) {
72 const int32_t kiStride = 0;71 const int32_t kiStride = 0;
73 72
74 uint8_t *pPred = new uint8_t[64];73 uint8_t* pPred = new uint8_t[64];
75 uint8_t *pRef = new uint8_t[64];74 uint8_t* pRef = new uint8_t[64];
76 for (int i=0; i<64; i++)75 for (int i = 0; i < 64; i++)
77 pRef[i] = rand() % 256;76 pRef[i] = rand() % 256;
78 77
79 const uint8_t kuiT0 = pRef[-kiStride];78 const uint8_t kuiT0 = pRef[-kiStride];
80 const uint8_t kuiT1 = pRef[1-kiStride];79 const uint8_t kuiT1 = pRef[1 - kiStride];
81 const uint8_t kuiT2 = pRef[2-kiStride];80 const uint8_t kuiT2 = pRef[2 - kiStride];
82 const uint8_t kuiT3 = pRef[3-kiStride];81 const uint8_t kuiT3 = pRef[3 - kiStride];
83 const uint8_t kuiT4 = pRef[4-kiStride];82 const uint8_t kuiT4 = pRef[4 - kiStride];
84 const uint8_t kuiT5 = pRef[5-kiStride];83 const uint8_t kuiT5 = pRef[5 - kiStride];
85 const uint8_t kuiT6 = pRef[6-kiStride];84 const uint8_t kuiT6 = pRef[6 - kiStride];
86 const uint8_t kuiT7 = pRef[7-kiStride];85 const uint8_t kuiT7 = pRef[7 - kiStride];
87 const uint8_t kuiDDL0 = (2 + kuiT0 + kuiT2 + (kuiT1<<1))>>2;86 const uint8_t kuiDDL0 = (2 + kuiT0 + kuiT2 + (kuiT1 << 1)) >> 2;
88 const uint8_t kuiDDL1 = (2 + kuiT1 + kuiT3 + (kuiT2<<1))>>2;87 const uint8_t kuiDDL1 = (2 + kuiT1 + kuiT3 + (kuiT2 << 1)) >> 2;
89 const uint8_t kuiDDL2 = (2 + kuiT2 + kuiT4 + (kuiT3<<1))>>2;88 const uint8_t kuiDDL2 = (2 + kuiT2 + kuiT4 + (kuiT3 << 1)) >> 2;
90 const uint8_t kuiDDL3 = (2 + kuiT3 + kuiT5 + (kuiT4<<1))>>2;89 const uint8_t kuiDDL3 = (2 + kuiT3 + kuiT5 + (kuiT4 << 1)) >> 2;
91 const uint8_t kuiDDL4 = (2 + kuiT4 + kuiT6 + (kuiT5<<1))>>2;90 const uint8_t kuiDDL4 = (2 + kuiT4 + kuiT6 + (kuiT5 << 1)) >> 2;
92 const uint8_t kuiDDL5 = (2 + kuiT5 + kuiT7 + (kuiT6<<1))>>2;91 const uint8_t kuiDDL5 = (2 + kuiT5 + kuiT7 + (kuiT6 << 1)) >> 2;
93 const uint8_t kuiDDL6 = (2 + kuiT6 + kuiT7 + (kuiT7<<1))>>2;92 const uint8_t kuiDDL6 = (2 + kuiT6 + kuiT7 + (kuiT7 << 1)) >> 2;
94 ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows93 ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
95 uiV[0] = kuiDDL0;94 uiV[0] = kuiDDL0;
96 uiV[1] = uiV[4] = kuiDDL1;95 uiV[1] = uiV[4] = kuiDDL1;
97 uiV[2] = uiV[5] = uiV[8] = kuiDDL2;96 uiV[2] = uiV[5] = uiV[8] = kuiDDL2;
98 uiV[3] = uiV[6] = uiV[9] = uiV[12] = kuiDDL3;97 uiV[3] = uiV[6] = uiV[9] = uiV[12] = kuiDDL3;
99 uiV[7] = uiV[10]= uiV[13]= kuiDDL4;98 uiV[7] = uiV[10] = uiV[13] = kuiDDL4;
100 uiV[11]= uiV[14]= kuiDDL5;99 uiV[11] = uiV[14] = kuiDDL5;
101 uiV[15] = kuiDDL6;100 uiV[15] = kuiDDL6;
102 101
103 const uint32_t kuiCpuFlag = 0;102 const uint32_t kuiCpuFlag = 0;
104 WelsInitFillingPredFuncs(kuiCpuFlag);103 WelsInitFillingPredFuncs (kuiCpuFlag);
105 WelsI4x4LumaPredDDL_c(pPred, pRef, kiStride);104 WelsI4x4LumaPredDDL_c (pPred, pRef, kiStride);
106 105
107 for (int i=0; i<4; i++)106 for (int i = 0; i < 4; i++)
108 EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i]));107 EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
109 108
110 delete []pRef;109 delete []pRef;
111 delete []pPred;110 delete []pPred;
112}111}
113 112
114TEST(GetIntraPredictorTest, TestGetI4x4LumaPredDDLTop) {113TEST (GetIntraPredictorTest, TestGetI4x4LumaPredDDLTop) {
115 const int32_t kiStride = 0;114 const int32_t kiStride = 0;
116 115
117 uint8_t *pPred = new uint8_t[64];116 uint8_t* pPred = new uint8_t[64];
118 uint8_t *pRef = new uint8_t[64];117 uint8_t* pRef = new uint8_t[64];
119 for (int i=0; i<64; i++)118 for (int i = 0; i < 64; i++)
120 pRef[i] = rand() % 256;119 pRef[i] = rand() % 256;
121 120
122 const uint8_t kuiT0 = pRef[-kiStride];121 const uint8_t kuiT0 = pRef[-kiStride];
123 const uint8_t kuiT1 = pRef[1-kiStride];122 const uint8_t kuiT1 = pRef[1 - kiStride];
124 const uint8_t kuiT2 = pRef[2-kiStride];123 const uint8_t kuiT2 = pRef[2 - kiStride];
125 const uint8_t kuiT3 = pRef[3-kiStride];124 const uint8_t kuiT3 = pRef[3 - kiStride];
126 const uint8_t kuiDLT0 = (2 + kuiT0 + kuiT2 + (kuiT1<<1))>>2;125 const uint8_t kuiDLT0 = (2 + kuiT0 + kuiT2 + (kuiT1 << 1)) >> 2;
127 const uint8_t kuiDLT1 = (2 + kuiT1 + kuiT3 + (kuiT2<<1))>>2;126 const uint8_t kuiDLT1 = (2 + kuiT1 + kuiT3 + (kuiT2 << 1)) >> 2;
128 const uint8_t kuiDLT2 = (2 + kuiT2 + kuiT3 + (kuiT3<<1))>>2;127 const uint8_t kuiDLT2 = (2 + kuiT2 + kuiT3 + (kuiT3 << 1)) >> 2;
129 const uint8_t kuiDLT3 = (2 + (kuiT3<<2))>>2;128 const uint8_t kuiDLT3 = (2 + (kuiT3 << 2)) >> 2;
130 ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows129 ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
131 memset(&uiV[6], kuiDLT3, 10*sizeof(uint8_t));130 memset (&uiV[6], kuiDLT3, 10 * sizeof (uint8_t));
132 uiV[0] = kuiDLT0;131 uiV[0] = kuiDLT0;
133 uiV[1] = uiV[4] = kuiDLT1;132 uiV[1] = uiV[4] = kuiDLT1;
134 uiV[2] = uiV[5] = uiV[8] = kuiDLT2;133 uiV[2] = uiV[5] = uiV[8] = kuiDLT2;
135 uiV[3] = kuiDLT3;134 uiV[3] = kuiDLT3;
136 135
137 const uint32_t kuiCpuFlag = 0;136 const uint32_t kuiCpuFlag = 0;
138 WelsInitFillingPredFuncs(kuiCpuFlag);137 WelsInitFillingPredFuncs (kuiCpuFlag);
139 WelsI4x4LumaPredDDLTop_c(pPred, pRef, kiStride);138 WelsI4x4LumaPredDDLTop_c (pPred, pRef, kiStride);
140 139
141 for (int i=0; i<4; i++)140 for (int i = 0; i < 4; i++)
142 EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i]));141 EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
143 142
144 delete []pRef;143 delete []pRef;
145 delete []pPred;144 delete []pPred;
146}145}
147 146
148TEST(GetIntraPredictorTest, TestGetI4x4LumaPredDDR) {147TEST (GetIntraPredictorTest, TestGetI4x4LumaPredDDR) {
149 const int32_t kiStride = rand()%256+16;148 const int32_t kiStride = rand() % 256 + 16;
150 const int32_t kiStride2 = kiStride<<1;149 const int32_t kiStride2 = kiStride << 1;
151 const int32_t kiStride3 = kiStride + kiStride2;150 const int32_t kiStride3 = kiStride + kiStride2;
152 151
153 uint8_t *pPred = new uint8_t[64];152 uint8_t* pPred = new uint8_t[64];
154 uint8_t *pRef = new uint8_t[kiStride3+kiStride+1];153 uint8_t* pRef = new uint8_t[kiStride3 + kiStride + 1];
155 154
156 for (int i=0; i<kiStride3+kiStride+1; i++)155 for (int i = 0; i < kiStride3 + kiStride + 1; i++)
157 pRef[i] = rand() % 256;156 pRef[i] = rand() % 256;
158 157
159 pRef += kiStride + 1;158 pRef += kiStride + 1;
160 159
161 const uint8_t kuiLT = pRef[-kiStride-1];160 const uint8_t kuiLT = pRef[-kiStride - 1];
162 const uint8_t kuiL0 = pRef[-1];161 const uint8_t kuiL0 = pRef[-1];
163 const uint8_t kuiL1 = pRef[kiStride-1];162 const uint8_t kuiL1 = pRef[kiStride - 1];
164 const uint8_t kuiL2 = pRef[kiStride2-1];163 const uint8_t kuiL2 = pRef[kiStride2 - 1];
165 const uint8_t kuiL3 = pRef[kiStride3-1];164 const uint8_t kuiL3 = pRef[kiStride3 - 1];
166 const uint8_t kuiT0 = pRef[-kiStride];165 const uint8_t kuiT0 = pRef[-kiStride];
167 const uint8_t kuiT1 = pRef[1-kiStride];166 const uint8_t kuiT1 = pRef[1 - kiStride];
168 const uint8_t kuiT2 = pRef[2-kiStride];167 const uint8_t kuiT2 = pRef[2 - kiStride];
169 const uint8_t kuiT3 = pRef[3-kiStride];168 const uint8_t kuiT3 = pRef[3 - kiStride];
170 const uint16_t kuiTL0 = 1 + kuiLT + kuiL0;169 const uint16_t kuiTL0 = 1 + kuiLT + kuiL0;
171 const uint16_t kuiLT0 = 1 + kuiLT + kuiT0;170 const uint16_t kuiLT0 = 1 + kuiLT + kuiT0;
172 const uint16_t kuiT01 = 1 + kuiT0 + kuiT1;171 const uint16_t kuiT01 = 1 + kuiT0 + kuiT1;
@@ -182,21 +181,21 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredDDR) { · 9 unmodified lines
182 const uint8_t kuiDDR4 = (kuiTL0 + kuiL01) >> 2;181 const uint8_t kuiDDR4 = (kuiTL0 + kuiL01) >> 2;
183 const uint8_t kuiDDR5 = (kuiL01 + kuiL12) >> 2;182 const uint8_t kuiDDR5 = (kuiL01 + kuiL12) >> 2;
184 const uint8_t kuiDDR6 = (kuiL12 + kuiL23) >> 2;183 const uint8_t kuiDDR6 = (kuiL12 + kuiL23) >> 2;
185 ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows184 ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
186 uiV[0] = uiV[5] = uiV[10] = uiV[15] = kuiDDR0;185 uiV[0] = uiV[5] = uiV[10] = uiV[15] = kuiDDR0;
187 uiV[1] = uiV[6] = uiV[11] = kuiDDR1;186 uiV[1] = uiV[6] = uiV[11] = kuiDDR1;
188 uiV[2] = uiV[7] = kuiDDR2;187 uiV[2] = uiV[7] = kuiDDR2;
189 uiV[3] = kuiDDR3;188 uiV[3] = kuiDDR3;
190 uiV[4] = uiV[9] = uiV[14] = kuiDDR4;189 uiV[4] = uiV[9] = uiV[14] = kuiDDR4;
191 uiV[8] = uiV[13] = kuiDDR5;190 uiV[8] = uiV[13] = kuiDDR5;
192 uiV[12]= kuiDDR6;191 uiV[12] = kuiDDR6;
193 192
194 const uint32_t kuiCpuFlag = 0;193 const uint32_t kuiCpuFlag = 0;
195 WelsInitFillingPredFuncs(kuiCpuFlag);194 WelsInitFillingPredFuncs (kuiCpuFlag);
196 WelsI4x4LumaPredDDR_c(pPred, pRef, kiStride);195 WelsI4x4LumaPredDDR_c (pPred, pRef, kiStride);
197 196
198 for (int i=0; i<4; i++)197 for (int i = 0; i < 4; i++)
199 EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i]));198 EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
200 199
201 pRef -= kiStride + 1;200 pRef -= kiStride + 1;
202 201
@@ -204,94 +203,94 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredDDR) { · 1 unmodified line
204 delete []pPred;203 delete []pPred;
205}204}
206 205
207TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVL) {206TEST (GetIntraPredictorTest, TestGetI4x4LumaPredVL) {
208 const int32_t kiStride = 0;207 const int32_t kiStride = 0;
209 208
210 uint8_t *pPred = new uint8_t[64];209 uint8_t* pPred = new uint8_t[64];
211 uint8_t *pRef = new uint8_t[64];210 uint8_t* pRef = new uint8_t[64];
212 for (int i=0; i<64; i++)211 for (int i = 0; i < 64; i++)
213 pRef[i] = rand() % 256;212 pRef[i] = rand() % 256;
214 213
215 const uint8_t kuiT0 = pRef[-kiStride];214 const uint8_t kuiT0 = pRef[-kiStride];
216 const uint8_t kuiT1 = pRef[1-kiStride];215 const uint8_t kuiT1 = pRef[1 - kiStride];
217 const uint8_t kuiT2 = pRef[2-kiStride];216 const uint8_t kuiT2 = pRef[2 - kiStride];
218 const uint8_t kuiT3 = pRef[3-kiStride];217 const uint8_t kuiT3 = pRef[3 - kiStride];
219 const uint8_t kuiT4 = pRef[4-kiStride];218 const uint8_t kuiT4 = pRef[4 - kiStride];
220 const uint8_t kuiT5 = pRef[5-kiStride];219 const uint8_t kuiT5 = pRef[5 - kiStride];
221 const uint8_t kuiT6 = pRef[6-kiStride];220 const uint8_t kuiT6 = pRef[6 - kiStride];
222 const uint8_t kuiVL0 = (1 + kuiT0 + kuiT1)>>1;221 const uint8_t kuiVL0 = (1 + kuiT0 + kuiT1) >> 1;
223 const uint8_t kuiVL1 = (1 + kuiT1 + kuiT2)>>1;222 const uint8_t kuiVL1 = (1 + kuiT1 + kuiT2) >> 1;
224 const uint8_t kuiVL2 = (1 + kuiT2 + kuiT3)>>1;223 const uint8_t kuiVL2 = (1 + kuiT2 + kuiT3) >> 1;
225 const uint8_t kuiVL3 = (1 + kuiT3 + kuiT4)>>1;224 const uint8_t kuiVL3 = (1 + kuiT3 + kuiT4) >> 1;
226 const uint8_t kuiVL4 = (1 + kuiT4 + kuiT5)>>1;225 const uint8_t kuiVL4 = (1 + kuiT4 + kuiT5) >> 1;
227 const uint8_t kuiVL5 = (2 + kuiT0 + (kuiT1<<1) + kuiT2)>>2;226 const uint8_t kuiVL5 = (2 + kuiT0 + (kuiT1 << 1) + kuiT2) >> 2;
228 const uint8_t kuiVL6 = (2 + kuiT1 + (kuiT2<<1) + kuiT3)>>2;227 const uint8_t kuiVL6 = (2 + kuiT1 + (kuiT2 << 1) + kuiT3) >> 2;
229 const uint8_t kuiVL7 = (2 + kuiT2 + (kuiT3<<1) + kuiT4)>>2;228 const uint8_t kuiVL7 = (2 + kuiT2 + (kuiT3 << 1) + kuiT4) >> 2;
230 const uint8_t kuiVL8 = (2 + kuiT3 + (kuiT4<<1) + kuiT5)>>2;229 const uint8_t kuiVL8 = (2 + kuiT3 + (kuiT4 << 1) + kuiT5) >> 2;
231 const uint8_t kuiVL9 = (2 + kuiT4 + (kuiT5<<1) + kuiT6)>>2;230 const uint8_t kuiVL9 = (2 + kuiT4 + (kuiT5 << 1) + kuiT6) >> 2;
232 ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows231 ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
233 uiV[0] = kuiVL0;232 uiV[0] = kuiVL0;
234 uiV[1] = uiV[8] = kuiVL1;233 uiV[1] = uiV[8] = kuiVL1;
235 uiV[2] = uiV[9] = kuiVL2;234 uiV[2] = uiV[9] = kuiVL2;
236 uiV[3] = uiV[10]= kuiVL3;235 uiV[3] = uiV[10] = kuiVL3;
237 uiV[4] = kuiVL5;236 uiV[4] = kuiVL5;
238 uiV[5] = uiV[12] = kuiVL6;237 uiV[5] = uiV[12] = kuiVL6;
239 uiV[6] = uiV[13] = kuiVL7;238 uiV[6] = uiV[13] = kuiVL7;
240 uiV[7] = uiV[14] = kuiVL8;239 uiV[7] = uiV[14] = kuiVL8;
241 uiV[11]= kuiVL4;240 uiV[11] = kuiVL4;
242 uiV[15]= kuiVL9;241 uiV[15] = kuiVL9;
243 242
244 const uint32_t kuiCpuFlag = 0;243 const uint32_t kuiCpuFlag = 0;
245 WelsInitFillingPredFuncs(kuiCpuFlag);244 WelsInitFillingPredFuncs (kuiCpuFlag);
246 WelsI4x4LumaPredVL_c(pPred, pRef, kiStride);245 WelsI4x4LumaPredVL_c (pPred, pRef, kiStride);
247 246
248 for (int i=0; i<4; i++)247 for (int i = 0; i < 4; i++)
249 EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i]));248 EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
250 249
251 delete []pRef;250 delete []pRef;
252 delete []pPred;251 delete []pPred;
253}252}
254 253
255TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVLTop) {254TEST (GetIntraPredictorTest, TestGetI4x4LumaPredVLTop) {
256 const int32_t kiStride = 0;255 const int32_t kiStride = 0;
257 256
258 uint8_t *pPred = new uint8_t[64];257 uint8_t* pPred = new uint8_t[64];
259 uint8_t *pRef = new uint8_t[64];258 uint8_t* pRef = new uint8_t[64];
260 for (int i=0; i<64; i++)259 for (int i = 0; i < 64; i++)
261 pRef[i] = rand() % 256;260 pRef[i] = rand() % 256;
262 261
263 pRef++;262 pRef++;
264 263
265 uint8_t *pTopLeft = &pRef[-kiStride-1]; // top-left264 uint8_t* pTopLeft = &pRef[-kiStride - 1]; // top-left
266 265
267 const uint8_t kuiT0 = *(pTopLeft+1);266 const uint8_t kuiT0 = * (pTopLeft + 1);
268 const uint8_t kuiT1 = *(pTopLeft+2);267 const uint8_t kuiT1 = * (pTopLeft + 2);
269 const uint8_t kuiT2 = *(pTopLeft+3);268 const uint8_t kuiT2 = * (pTopLeft + 3);
270 const uint8_t kuiT3 = *(pTopLeft+4);269 const uint8_t kuiT3 = * (pTopLeft + 4);
271 const uint8_t kuiVLT0 = (1 + kuiT0 + kuiT1)>>1;270 const uint8_t kuiVLT0 = (1 + kuiT0 + kuiT1) >> 1;
272 const uint8_t kuiVLT1 = (1 + kuiT1 + kuiT2)>>1;271 const uint8_t kuiVLT1 = (1 + kuiT1 + kuiT2) >> 1;
273 const uint8_t kuiVLT2 = (1 + kuiT2 + kuiT3)>>1;272 const uint8_t kuiVLT2 = (1 + kuiT2 + kuiT3) >> 1;
274 const uint8_t kuiVLT3 = (1 + (kuiT3<<1))>>1;273 const uint8_t kuiVLT3 = (1 + (kuiT3 << 1)) >> 1;
275 const uint8_t kuiVLT4 = (2 + kuiT0 + (kuiT1<<1) + kuiT2)>>2;274 const uint8_t kuiVLT4 = (2 + kuiT0 + (kuiT1 << 1) + kuiT2) >> 2;
276 const uint8_t kuiVLT5 = (2 + kuiT1 + (kuiT2<<1) + kuiT3)>>2;275 const uint8_t kuiVLT5 = (2 + kuiT1 + (kuiT2 << 1) + kuiT3) >> 2;
277 const uint8_t kuiVLT6 = (2 + kuiT2 + (kuiT3<<1) + kuiT3)>>2;276 const uint8_t kuiVLT6 = (2 + kuiT2 + (kuiT3 << 1) + kuiT3) >> 2;
278 const uint8_t kuiVLT7 = (2 + (kuiT3<<2))>>2;277 const uint8_t kuiVLT7 = (2 + (kuiT3 << 2)) >> 2;
279 ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows278 ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
280 uiV[0] = kuiVLT0;279 uiV[0] = kuiVLT0;
281 uiV[1] = uiV[8] = kuiVLT1;280 uiV[1] = uiV[8] = kuiVLT1;
282 uiV[2] = uiV[9] = kuiVLT2;281 uiV[2] = uiV[9] = kuiVLT2;
283 uiV[3] = uiV[10]= uiV[11] = kuiVLT3;282 uiV[3] = uiV[10] = uiV[11] = kuiVLT3;
284 uiV[4] = kuiVLT4;283 uiV[4] = kuiVLT4;
285 uiV[5] = uiV[12] = kuiVLT5;284 uiV[5] = uiV[12] = kuiVLT5;
286 uiV[6] = uiV[13] = kuiVLT6;285 uiV[6] = uiV[13] = kuiVLT6;
287 uiV[7] = uiV[14] = uiV[15] = kuiVLT7;286 uiV[7] = uiV[14] = uiV[15] = kuiVLT7;
288 287
289 const uint32_t kuiCpuFlag = 0;288 const uint32_t kuiCpuFlag = 0;
290 WelsInitFillingPredFuncs(kuiCpuFlag);289 WelsInitFillingPredFuncs (kuiCpuFlag);
291 WelsI4x4LumaPredVLTop_c(pPred, pRef, kiStride);290 WelsI4x4LumaPredVLTop_c (pPred, pRef, kiStride);
292 291
293 for (int i=0; i<4; i++)292 for (int i = 0; i < 4; i++)
294 EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i]));293 EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
295 294
296 pRef--;295 pRef--;
297 296
@@ -299,26 +298,26 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVLTop) { · 1 unmodified line
299 delete []pPred;298 delete []pPred;
300}299}
301 300
302TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVR) {301TEST (GetIntraPredictorTest, TestGetI4x4LumaPredVR) {
303 const int32_t kiStride = rand()%256+16;302 const int32_t kiStride = rand() % 256 + 16;
304 const int32_t kiStride2 = kiStride<<1;303 const int32_t kiStride2 = kiStride << 1;
305 304
306 uint8_t *pPred = new uint8_t[64];305 uint8_t* pPred = new uint8_t[64];
307 uint8_t *pRef = new uint8_t[kiStride2+kiStride+1];306 uint8_t* pRef = new uint8_t[kiStride2 + kiStride + 1];
308 307
309 for (int i=0; i<kiStride2+kiStride+1; i++)308 for (int i = 0; i < kiStride2 + kiStride + 1; i++)
310 pRef[i] = rand() % 256;309 pRef[i] = rand() % 256;
311 310
312 pRef += kiStride + 1;311 pRef += kiStride + 1;
313 312
314 const uint8_t kuiLT = pRef[-kiStride-1]; // top-left313 const uint8_t kuiLT = pRef[-kiStride - 1]; // top-left
315 const uint8_t kuiL0 = pRef[-1];314 const uint8_t kuiL0 = pRef[-1];
316 const uint8_t kuiL1 = pRef[kiStride-1];315 const uint8_t kuiL1 = pRef[kiStride - 1];
317 const uint8_t kuiL2 = pRef[kiStride2-1];316 const uint8_t kuiL2 = pRef[kiStride2 - 1];
318 const uint8_t kuiT0 = pRef[-kiStride];317 const uint8_t kuiT0 = pRef[-kiStride];
319 const uint8_t kuiT1 = pRef[1-kiStride];318 const uint8_t kuiT1 = pRef[1 - kiStride];
320 const uint8_t kuiT2 = pRef[2-kiStride];319 const uint8_t kuiT2 = pRef[2 - kiStride];
321 const uint8_t kuiT3 = pRef[3-kiStride];320 const uint8_t kuiT3 = pRef[3 - kiStride];
322 const uint8_t kuiVR0 = (1 + kuiLT + kuiT0) >> 1;321 const uint8_t kuiVR0 = (1 + kuiLT + kuiT0) >> 1;
323 const uint8_t kuiVR1 = (1 + kuiT0 + kuiT1) >> 1;322 const uint8_t kuiVR1 = (1 + kuiT0 + kuiT1) >> 1;
324 const uint8_t kuiVR2 = (1 + kuiT1 + kuiT2) >> 1;323 const uint8_t kuiVR2 = (1 + kuiT1 + kuiT2) >> 1;
@@ -329,7 +328,7 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVR) { · 4 unmodified lines
329 const uint8_t kuiVR7 = (2 + kuiT1 + (kuiT2 << 1) + kuiT3) >> 2;328 const uint8_t kuiVR7 = (2 + kuiT1 + (kuiT2 << 1) + kuiT3) >> 2;
330 const uint8_t kuiVR8 = (2 + kuiLT + (kuiL0 << 1) + kuiL1) >> 2;329 const uint8_t kuiVR8 = (2 + kuiLT + (kuiL0 << 1) + kuiL1) >> 2;
331 const uint8_t kuiVR9 = (2 + kuiL0 + (kuiL1 << 1) + kuiL2) >> 2;330 const uint8_t kuiVR9 = (2 + kuiL0 + (kuiL1 << 1) + kuiL2) >> 2;
332 ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows331 ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
333 uiV[0] = uiV[9] = kuiVR0;332 uiV[0] = uiV[9] = kuiVR0;
334 uiV[1] = uiV[10] = kuiVR1;333 uiV[1] = uiV[10] = kuiVR1;
335 uiV[2] = uiV[11] = kuiVR2;334 uiV[2] = uiV[11] = kuiVR2;
@@ -339,14 +338,14 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVR) { · 3 unmodified lines
339 uiV[6] = uiV[15] = kuiVR6;338 uiV[6] = uiV[15] = kuiVR6;
340 uiV[7] = kuiVR7;339 uiV[7] = kuiVR7;
341 uiV[8] = kuiVR8;340 uiV[8] = kuiVR8;
342 uiV[12]= kuiVR9;341 uiV[12] = kuiVR9;
343 342
344 const uint32_t kuiCpuFlag = 0;343 const uint32_t kuiCpuFlag = 0;
345 WelsInitFillingPredFuncs(kuiCpuFlag);344 WelsInitFillingPredFuncs (kuiCpuFlag);
346 WelsI4x4LumaPredVR_c(pPred, pRef, kiStride);345 WelsI4x4LumaPredVR_c (pPred, pRef, kiStride);
347 346
348 for (int i=0; i<4; i++)347 for (int i = 0; i < 4; i++)
349 EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i]));348 EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
350 349
351 pRef -= kiStride + 1;350 pRef -= kiStride + 1;
352 351
@@ -354,23 +353,23 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVR) { · 1 unmodified line
354 delete []pPred;353 delete []pPred;
355}354}
356 355
357TEST(GetIntraPredictorTest, TestGetI4x4LumaPredHU) {356TEST (GetIntraPredictorTest, TestGetI4x4LumaPredHU) {
358 const int32_t kiStride = rand()%256+16;357 const int32_t kiStride = rand() % 256 + 16;
359 const int32_t kiStride2 = kiStride<<1;358 const int32_t kiStride2 = kiStride << 1;
360 const int32_t kiStride3 = kiStride + kiStride2;359 const int32_t kiStride3 = kiStride + kiStride2;
361 360
362 uint8_t *pPred = new uint8_t[64];361 uint8_t* pPred = new uint8_t[64];
363 uint8_t *pRef = new uint8_t[kiStride3+1];362 uint8_t* pRef = new uint8_t[kiStride3 + 1];
364 363
365 for (int i=0; i<kiStride3+1; i++)364 for (int i = 0; i < kiStride3 + 1; i++)
366 pRef[i] = rand() % 256;365 pRef[i] = rand() % 256;
367 366
368 pRef++;367 pRef++;
369 368
370 const uint8_t kuiL0 = pRef[-1];369 const uint8_t kuiL0 = pRef[-1];
371 const uint8_t kuiL1 = pRef[kiStride-1];370 const uint8_t kuiL1 = pRef[kiStride - 1];
372 const uint8_t kuiL2 = pRef[kiStride2-1];371 const uint8_t kuiL2 = pRef[kiStride2 - 1];
373 const uint8_t kuiL3 = pRef[kiStride3-1];372 const uint8_t kuiL3 = pRef[kiStride3 - 1];
374 const uint16_t kuiL01 = (1 + kuiL0 + kuiL1);373 const uint16_t kuiL01 = (1 + kuiL0 + kuiL1);
375 const uint16_t kuiL12 = (1 + kuiL1 + kuiL2);374 const uint16_t kuiL12 = (1 + kuiL1 + kuiL2);
376 const uint16_t kuiL23 = (1 + kuiL2 + kuiL3);375 const uint16_t kuiL23 = (1 + kuiL2 + kuiL3);
@@ -380,21 +379,21 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredHU) { · 3 unmodified lines
380 const uint8_t kuiHU3 = (kuiL12 + kuiL23) >> 2;379 const uint8_t kuiHU3 = (kuiL12 + kuiL23) >> 2;
381 const uint8_t kuiHU4 = kuiL23 >> 1;380 const uint8_t kuiHU4 = kuiL23 >> 1;
382 const uint8_t kuiHU5 = (1 + kuiL23 + (kuiL3 << 1)) >> 2;381 const uint8_t kuiHU5 = (1 + kuiL23 + (kuiL3 << 1)) >> 2;
383 ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows382 ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
384 uiV[0] = kuiHU0;383 uiV[0] = kuiHU0;
385 uiV[1] = kuiHU1;384 uiV[1] = kuiHU1;
386 uiV[2] = uiV[4] = kuiHU2;385 uiV[2] = uiV[4] = kuiHU2;
387 uiV[3] = uiV[5] = kuiHU3;386 uiV[3] = uiV[5] = kuiHU3;
388 uiV[6] = uiV[8] = kuiHU4;387 uiV[6] = uiV[8] = kuiHU4;
389 uiV[7] = uiV[9] = kuiHU5;388 uiV[7] = uiV[9] = kuiHU5;
390 memset(&uiV[10], kuiL3, 6*sizeof(uint8_t));389 memset (&uiV[10], kuiL3, 6 * sizeof (uint8_t));
391 390
392 const uint32_t kuiCpuFlag = 0;391 const uint32_t kuiCpuFlag = 0;
393 WelsInitFillingPredFuncs(kuiCpuFlag);392 WelsInitFillingPredFuncs (kuiCpuFlag);
394 WelsI4x4LumaPredHU_c(pPred, pRef, kiStride);393 WelsI4x4LumaPredHU_c (pPred, pRef, kiStride);
395 394
396 for (int i=0; i<4; i++)395 for (int i = 0; i < 4; i++)
397 EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i]));396 EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
398 397
399 pRef--;398 pRef--;
400 399
@@ -402,38 +401,38 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredHU) { · 1 unmodified line
402 delete []pPred;401 delete []pPred;
403}402}
404 403
405TEST(GetIntraPredictorTest, TestGetI4x4LumaPredHD) {404TEST (GetIntraPredictorTest, TestGetI4x4LumaPredHD) {
406 const int32_t kiStride = rand()%256+16;405 const int32_t kiStride = rand() % 256 + 16;
407 const int32_t kiStride2 = kiStride<<1;406 const int32_t kiStride2 = kiStride << 1;
408 const int32_t kiStride3 = kiStride + kiStride2;407 const int32_t kiStride3 = kiStride + kiStride2;
409 408
410 uint8_t *pPred = new uint8_t[64];409 uint8_t* pPred = new uint8_t[64];
411 uint8_t *pRef = new uint8_t[kiStride3+kiStride+1];410 uint8_t* pRef = new uint8_t[kiStride3 + kiStride + 1];
412 411
413 for (int i=0; i<kiStride3+kiStride+1; i++)412 for (int i = 0; i < kiStride3 + kiStride + 1; i++)
414 pRef[i] = rand() % 256;413 pRef[i] = rand() % 256;
415 414
416 pRef += kiStride + 1;415 pRef += kiStride + 1;
417 416
418 const uint8_t kuiLT = pRef[-kiStride-1]; // top-left417 const uint8_t kuiLT = pRef[-kiStride - 1]; // top-left
419 const uint8_t kuiL0 = pRef[-1];418 const uint8_t kuiL0 = pRef[-1];
420 const uint8_t kuiL1 = pRef[kiStride-1];419 const uint8_t kuiL1 = pRef[kiStride - 1];
421 const uint8_t kuiL2 = pRef[kiStride2-1];420 const uint8_t kuiL2 = pRef[kiStride2 - 1];
422 const uint8_t kuiL3 = pRef[kiStride3-1];421 const uint8_t kuiL3 = pRef[kiStride3 - 1];
423 const uint8_t kuiT0 = pRef[-kiStride];422 const uint8_t kuiT0 = pRef[-kiStride];
424 const uint8_t kuiT1 = pRef[1-kiStride];423 const uint8_t kuiT1 = pRef[1 - kiStride];
425 const uint8_t kuiT2 = pRef[2-kiStride];424 const uint8_t kuiT2 = pRef[2 - kiStride];
426 const uint8_t kuiHD0 = (1 + kuiLT + kuiL0)>>1;425 const uint8_t kuiHD0 = (1 + kuiLT + kuiL0) >> 1;
427 const uint8_t kuiHD1 = (2 + kuiL0 + (kuiLT<<1) + kuiT0)>>2;426 const uint8_t kuiHD1 = (2 + kuiL0 + (kuiLT << 1) + kuiT0) >> 2;
428 const uint8_t kuiHD2 = (2 + kuiLT + (kuiT0<<1) + kuiT1)>>2;427 const uint8_t kuiHD2 = (2 + kuiLT + (kuiT0 << 1) + kuiT1) >> 2;
429 const uint8_t kuiHD3 = (2 + kuiT0 + (kuiT1<<1) + kuiT2)>>2;428 const uint8_t kuiHD3 = (2 + kuiT0 + (kuiT1 << 1) + kuiT2) >> 2;
430 const uint8_t kuiHD4 = (1 + kuiL0 + kuiL1)>>1;429 const uint8_t kuiHD4 = (1 + kuiL0 + kuiL1) >> 1;
431 const uint8_t kuiHD5 = (2 + kuiLT + (kuiL0<<1) + kuiL1)>>2;430 const uint8_t kuiHD5 = (2 + kuiLT + (kuiL0 << 1) + kuiL1) >> 2;
432 const uint8_t kuiHD6 = (1 + kuiL1 + kuiL2)>>1;431 const uint8_t kuiHD6 = (1 + kuiL1 + kuiL2) >> 1;
433 const uint8_t kuiHD7 = (2 + kuiL0 + (kuiL1<<1) + kuiL2)>>2;432 const uint8_t kuiHD7 = (2 + kuiL0 + (kuiL1 << 1) + kuiL2) >> 2;
434 const uint8_t kuiHD8 = (1 + kuiL2 + kuiL3)>>1;433 const uint8_t kuiHD8 = (1 + kuiL2 + kuiL3) >> 1;
435 const uint8_t kuiHD9 = (2 + kuiL1 + (kuiL2<<1) + kuiL3)>>2;434 const uint8_t kuiHD9 = (2 + kuiL1 + (kuiL2 << 1) + kuiL3) >> 2;
436 ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows435 ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
437 uiV[0] = uiV[6] = kuiHD0;436 uiV[0] = uiV[6] = kuiHD0;
438 uiV[1] = uiV[7] = kuiHD1;437 uiV[1] = uiV[7] = kuiHD1;
439 uiV[2] = kuiHD2;438 uiV[2] = kuiHD2;
@@ -446,11 +445,11 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredHD) { · 6 unmodified lines
446 uiV[13] = kuiHD9;445 uiV[13] = kuiHD9;
447 446
448 const uint32_t kuiCpuFlag = 0;447 const uint32_t kuiCpuFlag = 0;
449 WelsInitFillingPredFuncs(kuiCpuFlag);448 WelsInitFillingPredFuncs (kuiCpuFlag);
450 WelsI4x4LumaPredHD_c(pPred, pRef, kiStride);449 WelsI4x4LumaPredHD_c (pPred, pRef, kiStride);
451 450
452 for (int i=0; i<4; i++)451 for (int i = 0; i < 4; i++)
453 EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i]));452 EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
454 453
455 pRef -= kiStride + 1;454 pRef -= kiStride + 1;
456 455
@@ -458,52 +457,52 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredHD) { · 1 unmodified line
458 delete []pPred;457 delete []pPred;
459}458}
460 459
461TEST(GetIntraPredictorTest, TestGetIChormaPredV) {460TEST (GetIntraPredictorTest, TestGetIChormaPredV) {
462 uint8_t *pPred = new uint8_t[64];461 uint8_t* pPred = new uint8_t[64];
463 uint8_t *pRef = new uint8_t[64];462 uint8_t* pRef = new uint8_t[64];
464 for (int i=0; i<64; i++)463 for (int i = 0; i < 64; i++)
465 pRef[i] = rand() % 256 + 1;464 pRef[i] = rand() % 256 + 1;
466 465
467 const int32_t kiStride = 0;466 const int32_t kiStride = 0;
468 WelsIChormaPredV_c(pPred, pRef, kiStride);467 WelsIChormaPredV_c (pPred, pRef, kiStride);
469 468
470 for (int i=0; i<8; i++)469 for (int i = 0; i < 8; i++)
471 EXPECT_EQ(LD32(&pPred[8*i]),LD32(&pRef[-kiStride]));470 EXPECT_EQ (LD32 (&pPred[8 * i]), LD32 (&pRef[-kiStride]));
472 471
473 delete []pRef;472 delete []pRef;
474 delete []pPred;473 delete []pPred;
475}474}
476 475
477TEST(GetIntraPredictorTest, TestGetI16x16LumaPredPlane) {476TEST (GetIntraPredictorTest, TestGetI16x16LumaPredPlane) {
478 const int32_t kiStride = rand()%16+16;477 const int32_t kiStride = rand() % 16 + 16;
479 478
480 int32_t i, j;479 int32_t i, j;
481 480
482 uint8_t *pPred = new uint8_t[16*kiStride];481 uint8_t* pPred = new uint8_t[16 * kiStride];
483 uint8_t *pRef = new uint8_t[16*kiStride+1];482 uint8_t* pRef = new uint8_t[16 * kiStride + 1];
484 for (i=0; i<16*kiStride+1; i++)483 for (i = 0; i < 16 * kiStride + 1; i++)
485 pRef[i]=rand()%256+1;484 pRef[i] = rand() % 256 + 1;
486 485
487 pRef += kiStride + 1;486 pRef += kiStride + 1;
488 487
489 int32_t iA=0, iB=0, iC=0, iH=0, iV=0;488 int32_t iA = 0, iB = 0, iC = 0, iH = 0, iV = 0;
490 uint8_t *pTop = &pRef[-kiStride];489 uint8_t* pTop = &pRef[-kiStride];
491 uint8_t *pLeft = &pRef[-1];490 uint8_t* pLeft = &pRef[-1];
492 int32_t iPredStride = 16;491 int32_t iPredStride = 16;
493 492
494 for (i=0; i<8; i++) {493 for (i = 0; i < 8; i++) {
495 iH += (i + 1) * (pTop[8 + i] - pTop[6 - i]);494 iH += (i + 1) * (pTop[8 + i] - pTop[6 - i]);
496 iV += (i + 1) * (pLeft[(8 + i)*kiStride] - pLeft[(6 - i)*kiStride]);495 iV += (i + 1) * (pLeft[ (8 + i) * kiStride] - pLeft[ (6 - i) * kiStride]);
497 }496 }
498 497
499 iA = (pLeft[15*kiStride] + pTop[15]) << 4;498 iA = (pLeft[15 * kiStride] + pTop[15]) << 4;
500 iB = (5 * iH + 32) >> 6;499 iB = (5 * iH + 32) >> 6;
501 iC = (5 * iV + 32) >> 6;500 iC = (5 * iV + 32) >> 6;
502 501
503 WelsI16x16LumaPredPlane_c(pPred, pRef, kiStride);502 WelsI16x16LumaPredPlane_c (pPred, pRef, kiStride);
504 for (i=0; i<16; i++) {503 for (i = 0; i < 16; i++) {
505 for (j=0; j<16; j++) {504 for (j = 0; j < 16; j++) {
506 EXPECT_EQ(pPred[j],(uint8_t)WelsClip1((iA + iB * (j - 7) + iC * (i - 7) + 16) >> 5));505 EXPECT_EQ (pPred[j], (uint8_t)WelsClip1 ((iA + iB * (j - 7) + iC * (i - 7) + 16) >> 5));
507 }506 }
508 pPred += iPredStride;507 pPred += iPredStride;
509 }508 }
@@ -514,14 +513,14 @@ TEST(GetIntraPredictorTest, TestGetI16x16LumaPredPlane) { · 4 unmodified lines
514 delete []pPred;513 delete []pPred;
515}514}
516 515
517TEST(GetIntraPredictorTest, TestGetI16x16LumaPredDc) {516TEST (GetIntraPredictorTest, TestGetI16x16LumaPredDc) {
518 const int32_t kiStride = rand()%16+16;517 const int32_t kiStride = rand() % 16 + 16;
519 518
520 int i;519 int i;
521 520
522 uint8_t *pPred = new uint8_t[256];521 uint8_t* pPred = new uint8_t[256];
523 uint8_t *pRef = new uint8_t[16*kiStride];522 uint8_t* pRef = new uint8_t[16 * kiStride];
524 for (i=0; i<16*kiStride; i++)523 for (i = 0; i < 16 * kiStride; i++)
525 pRef[i] = rand() % 256 + 1;524 pRef[i] = rand() % 256 + 1;
526 525
527 pRef += kiStride;526 pRef += kiStride;
@@ -532,14 +531,14 @@ TEST(GetIntraPredictorTest, TestGetI16x16LumaPredDc) { · 4 unmodified lines
532 uint8_t uiMean = 0;531 uint8_t uiMean = 0;
533 532
534 do {533 do {
535 iSum += pRef[-1+iTmp] + pRef[-kiStride+i];534 iSum += pRef[-1 + iTmp] + pRef[-kiStride + i];
536 iTmp -= kiStride;535 iTmp -= kiStride;
537 } while(i-- > 0);536 } while (i-- > 0);
538 uiMean = ( 16 + iSum ) >> 5;537 uiMean = (16 + iSum) >> 5;
539 538
540 WelsI16x16LumaPredDc_c(pPred, pRef, kiStride);539 WelsI16x16LumaPredDc_c (pPred, pRef, kiStride);
541 for (i=0; i<256; i++)540 for (i = 0; i < 256; i++)
542 EXPECT_EQ(pPred[i],uiMean);541 EXPECT_EQ (pPred[i], uiMean);
543 542
544 pRef -= kiStride;543 pRef -= kiStride;
545 544
@@ -547,14 +546,14 @@ TEST(GetIntraPredictorTest, TestGetI16x16LumaPredDc) { · 1 unmodified line
547 delete []pPred;546 delete []pPred;
548}547}
549 548
550TEST(GetIntraPredictorTest, TestGetI16x16LumaPredDcTop) {549TEST (GetIntraPredictorTest, TestGetI16x16LumaPredDcTop) {
551 const int32_t kiStride = rand()%16+16;550 const int32_t kiStride = rand() % 16 + 16;
552 551
553 int i;552 int i;
554 553
555 uint8_t *pPred = new uint8_t[256];554 uint8_t* pPred = new uint8_t[256];
556 uint8_t *pRef = new uint8_t[16*kiStride];555 uint8_t* pRef = new uint8_t[16 * kiStride];
557 for (i=0; i<16*kiStride; i++)556 for (i = 0; i < 16 * kiStride; i++)
558 pRef[i] = rand() % 256 + 1;557 pRef[i] = rand() % 256 + 1;
559 558
560 pRef += kiStride;559 pRef += kiStride;
@@ -563,13 +562,13 @@ TEST(GetIntraPredictorTest, TestGetI16x16LumaPredDcTop) { · 2 unmodified lines
563 i = 15;562 i = 15;
564 uint8_t uiMean = 0;563 uint8_t uiMean = 0;
565 do {564 do {
566 iSum += pRef[-kiStride+i];565 iSum += pRef[-kiStride + i];
567 } while(i-- > 0);566 } while (i-- > 0);
568 uiMean = ( 8 + iSum ) >> 4;567 uiMean = (8 + iSum) >> 4;
569 568
570 WelsI16x16LumaPredDcTop_c(pPred, pRef, kiStride);569 WelsI16x16LumaPredDcTop_c (pPred, pRef, kiStride);
571 for (i=0; i<256; i++)570 for (i = 0; i < 256; i++)
572 EXPECT_EQ(pPred[i],uiMean);571 EXPECT_EQ (pPred[i], uiMean);
573 572
574 pRef -= kiStride;573 pRef -= kiStride;
575 574

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