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
77
88 using namespace WelsSVCEnc;
99
10−TEST(GetIntraPredictorTest, TestGetI4x4LumaPredV) {
11− uint8_t *pPred = new uint8_t[64];
12− uint8_t *pRef = new uint8_t[64];
13− for (int i=0; i<64; i++)
10+TEST (GetIntraPredictorTest, TestGetI4x4LumaPredV) {
11+ uint8_t* pPred = new uint8_t[64];
12+ uint8_t* pRef = new uint8_t[64];
13+ for (int i = 0; i < 64; i++)
1414 pRef[i] = rand() % 256;
1515
1616 const int32_t kkiStride = 0;
1717 const uint32_t kuiCpuFlag = 0;
18− WelsInitFillingPredFuncs(kuiCpuFlag);
19− WelsI4x4LumaPredV_c(pPred, pRef, kkiStride);
18+ WelsInitFillingPredFuncs (kuiCpuFlag);
19+ WelsI4x4LumaPredV_c (pPred, pRef, kkiStride);
2020
21− for (int i=0; i<4; i++)
22− EXPECT_EQ(LD32(&pPred[4*i]),LD32(&pRef[-kkiStride]));
21+ for (int i = 0; i < 4; i++)
22+ EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&pRef[-kkiStride]));
2323
2424 delete []pRef;
2525 delete []pPred;
2626 }
2727
28−TEST(GetIntraPredictorTest, TestGetI4x4LumaPredH)
29−{
30− const int32_t kiStride = rand()%256+16;
31− const uint32_t kiStride2 = (kiStride<<1)-1;
28+TEST (GetIntraPredictorTest, TestGetI4x4LumaPredH) {
29+ const int32_t kiStride = rand() % 256 + 16;
30+ const uint32_t kiStride2 = (kiStride << 1) - 1;
3231 const uint32_t kiStride3 = kiStride + kiStride2;
3332
34− uint8_t *pPred = new uint8_t[64];
35− uint8_t *pRef = new uint8_t[kiStride3+2];
33+ uint8_t* pPred = new uint8_t[64];
34+ uint8_t* pRef = new uint8_t[kiStride3 + 2];
3635
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++)
3837 pRef[i] = rand() % 256;
3938
4039 pRef++;
4140
4241 const uint8_t kuiH1 = pRef[-1];
43− const uint8_t kuiH2 = pRef[kiStride-1];
42+ const uint8_t kuiH2 = pRef[kiStride - 1];
4443 const uint8_t kuiH3 = pRef[kiStride2];
4544 const uint8_t kuiH4 = pRef[kiStride3];
4645 const uint8_t kuiV1[4] = {kuiH1, kuiH1, kuiH1, kuiH1};
@@ -50,17 +49,17 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredH) · 3 unmodified lines
5049
5150 const uint32_t kuiCpuFlag = 0;
5251
53− ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16)// TobeCont'd about assign opt as follows
54− ST32(&uiV[0], LD32(kuiV1));
55− ST32(&uiV[4], LD32(kuiV2));
56− ST32(&uiV[8], LD32(kuiV3));
57− ST32(&uiV[12], LD32(kuiV4));
52+ ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
53+ ST32 (&uiV[0], LD32 (kuiV1));
54+ ST32 (&uiV[4], LD32 (kuiV2));
55+ ST32 (&uiV[8], LD32 (kuiV3));
56+ ST32 (&uiV[12], LD32 (kuiV4));
5857
59− WelsInitFillingPredFuncs(kuiCpuFlag);
60− WelsI4x4LumaPredH_c(pPred, pRef, kiStride);
58+ WelsInitFillingPredFuncs (kuiCpuFlag);
59+ WelsI4x4LumaPredH_c (pPred, pRef, kiStride);
6160
62− for (int i=0; i<4; i++)
63− EXPECT_EQ(LD32(&pPred[4*i]), LD32(&uiV[4*i]));
61+ for (int i = 0; i < 4; i++)
62+ EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
6463
6564 pRef--;
6665
@@ -68,105 +67,105 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredH) · 1 unmodified line
6867 delete []pPred;
6968 }
7069
71−TEST(GetIntraPredictorTest, TestGetI4x4LumaPredDDL) {
70+TEST (GetIntraPredictorTest, TestGetI4x4LumaPredDDL) {
7271 const int32_t kiStride = 0;
7372
74− uint8_t *pPred = new uint8_t[64];
75− uint8_t *pRef = new uint8_t[64];
76− for (int i=0; i<64; i++)
73+ uint8_t* pPred = new uint8_t[64];
74+ uint8_t* pRef = new uint8_t[64];
75+ for (int i = 0; i < 64; i++)
7776 pRef[i] = rand() % 256;
7877
7978 const uint8_t kuiT0 = pRef[-kiStride];
80− const uint8_t kuiT1 = pRef[1-kiStride];
81− const uint8_t kuiT2 = pRef[2-kiStride];
82− const uint8_t kuiT3 = pRef[3-kiStride];
83− const uint8_t kuiT4 = pRef[4-kiStride];
84− const uint8_t kuiT5 = pRef[5-kiStride];
85− const uint8_t kuiT6 = pRef[6-kiStride];
86− const uint8_t kuiT7 = pRef[7-kiStride];
87− const uint8_t kuiDDL0 = (2 + kuiT0 + kuiT2 + (kuiT1<<1))>>2;
88− const uint8_t kuiDDL1 = (2 + kuiT1 + kuiT3 + (kuiT2<<1))>>2;
89− const uint8_t kuiDDL2 = (2 + kuiT2 + kuiT4 + (kuiT3<<1))>>2;
90− const uint8_t kuiDDL3 = (2 + kuiT3 + kuiT5 + (kuiT4<<1))>>2;
91− const uint8_t kuiDDL4 = (2 + kuiT4 + kuiT6 + (kuiT5<<1))>>2;
92− const uint8_t kuiDDL5 = (2 + kuiT5 + kuiT7 + (kuiT6<<1))>>2;
93− 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 follows
79+ const uint8_t kuiT1 = pRef[1 - kiStride];
80+ const uint8_t kuiT2 = pRef[2 - kiStride];
81+ const uint8_t kuiT3 = pRef[3 - kiStride];
82+ const uint8_t kuiT4 = pRef[4 - kiStride];
83+ const uint8_t kuiT5 = pRef[5 - kiStride];
84+ const uint8_t kuiT6 = pRef[6 - kiStride];
85+ const uint8_t kuiT7 = pRef[7 - kiStride];
86+ const uint8_t kuiDDL0 = (2 + kuiT0 + kuiT2 + (kuiT1 << 1)) >> 2;
87+ const uint8_t kuiDDL1 = (2 + kuiT1 + kuiT3 + (kuiT2 << 1)) >> 2;
88+ const uint8_t kuiDDL2 = (2 + kuiT2 + kuiT4 + (kuiT3 << 1)) >> 2;
89+ const uint8_t kuiDDL3 = (2 + kuiT3 + kuiT5 + (kuiT4 << 1)) >> 2;
90+ const uint8_t kuiDDL4 = (2 + kuiT4 + kuiT6 + (kuiT5 << 1)) >> 2;
91+ const uint8_t kuiDDL5 = (2 + kuiT5 + kuiT7 + (kuiT6 << 1)) >> 2;
92+ const uint8_t kuiDDL6 = (2 + kuiT6 + kuiT7 + (kuiT7 << 1)) >> 2;
93+ ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
9594 uiV[0] = kuiDDL0;
9695 uiV[1] = uiV[4] = kuiDDL1;
9796 uiV[2] = uiV[5] = uiV[8] = kuiDDL2;
9897 uiV[3] = uiV[6] = uiV[9] = uiV[12] = kuiDDL3;
99− uiV[7] = uiV[10]= uiV[13]= kuiDDL4;
100− uiV[11]= uiV[14]= kuiDDL5;
98+ uiV[7] = uiV[10] = uiV[13] = kuiDDL4;
99+ uiV[11] = uiV[14] = kuiDDL5;
101100 uiV[15] = kuiDDL6;
102101
103102 const uint32_t kuiCpuFlag = 0;
104− WelsInitFillingPredFuncs(kuiCpuFlag);
105− WelsI4x4LumaPredDDL_c(pPred, pRef, kiStride);
103+ WelsInitFillingPredFuncs (kuiCpuFlag);
104+ WelsI4x4LumaPredDDL_c (pPred, pRef, kiStride);
106105
107− for (int i=0; i<4; i++)
108− EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i]));
106+ for (int i = 0; i < 4; i++)
107+ EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
109108
110109 delete []pRef;
111110 delete []pPred;
112111 }
113112
114−TEST(GetIntraPredictorTest, TestGetI4x4LumaPredDDLTop) {
113+TEST (GetIntraPredictorTest, TestGetI4x4LumaPredDDLTop) {
115114 const int32_t kiStride = 0;
116115
117− uint8_t *pPred = new uint8_t[64];
118− uint8_t *pRef = new uint8_t[64];
119− for (int i=0; i<64; i++)
116+ uint8_t* pPred = new uint8_t[64];
117+ uint8_t* pRef = new uint8_t[64];
118+ for (int i = 0; i < 64; i++)
120119 pRef[i] = rand() % 256;
121120
122121 const uint8_t kuiT0 = pRef[-kiStride];
123− const uint8_t kuiT1 = pRef[1-kiStride];
124− const uint8_t kuiT2 = pRef[2-kiStride];
125− const uint8_t kuiT3 = pRef[3-kiStride];
126− const uint8_t kuiDLT0 = (2 + kuiT0 + kuiT2 + (kuiT1<<1))>>2;
127− const uint8_t kuiDLT1 = (2 + kuiT1 + kuiT3 + (kuiT2<<1))>>2;
128− const uint8_t kuiDLT2 = (2 + kuiT2 + kuiT3 + (kuiT3<<1))>>2;
129− const uint8_t kuiDLT3 = (2 + (kuiT3<<2))>>2;
130− 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));
122+ const uint8_t kuiT1 = pRef[1 - kiStride];
123+ const uint8_t kuiT2 = pRef[2 - kiStride];
124+ const uint8_t kuiT3 = pRef[3 - kiStride];
125+ const uint8_t kuiDLT0 = (2 + kuiT0 + kuiT2 + (kuiT1 << 1)) >> 2;
126+ const uint8_t kuiDLT1 = (2 + kuiT1 + kuiT3 + (kuiT2 << 1)) >> 2;
127+ const uint8_t kuiDLT2 = (2 + kuiT2 + kuiT3 + (kuiT3 << 1)) >> 2;
128+ const uint8_t kuiDLT3 = (2 + (kuiT3 << 2)) >> 2;
129+ ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
130+ memset (&uiV[6], kuiDLT3, 10 * sizeof (uint8_t));
132131 uiV[0] = kuiDLT0;
133132 uiV[1] = uiV[4] = kuiDLT1;
134133 uiV[2] = uiV[5] = uiV[8] = kuiDLT2;
135134 uiV[3] = kuiDLT3;
136135
137136 const uint32_t kuiCpuFlag = 0;
138− WelsInitFillingPredFuncs(kuiCpuFlag);
139− WelsI4x4LumaPredDDLTop_c(pPred, pRef, kiStride);
137+ WelsInitFillingPredFuncs (kuiCpuFlag);
138+ WelsI4x4LumaPredDDLTop_c (pPred, pRef, kiStride);
140139
141− for (int i=0; i<4; i++)
142− EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i]));
140+ for (int i = 0; i < 4; i++)
141+ EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
143142
144143 delete []pRef;
145144 delete []pPred;
146145 }
147146
148−TEST(GetIntraPredictorTest, TestGetI4x4LumaPredDDR) {
149− const int32_t kiStride = rand()%256+16;
150− const int32_t kiStride2 = kiStride<<1;
147+TEST (GetIntraPredictorTest, TestGetI4x4LumaPredDDR) {
148+ const int32_t kiStride = rand() % 256 + 16;
149+ const int32_t kiStride2 = kiStride << 1;
151150 const int32_t kiStride3 = kiStride + kiStride2;
152151
153− uint8_t *pPred = new uint8_t[64];
154− uint8_t *pRef = new uint8_t[kiStride3+kiStride+1];
152+ uint8_t* pPred = new uint8_t[64];
153+ uint8_t* pRef = new uint8_t[kiStride3 + kiStride + 1];
155154
156− for (int i=0; i<kiStride3+kiStride+1; i++)
155+ for (int i = 0; i < kiStride3 + kiStride + 1; i++)
157156 pRef[i] = rand() % 256;
158157
159158 pRef += kiStride + 1;
160159
161− const uint8_t kuiLT = pRef[-kiStride-1];
160+ const uint8_t kuiLT = pRef[-kiStride - 1];
162161 const uint8_t kuiL0 = pRef[-1];
163− const uint8_t kuiL1 = pRef[kiStride-1];
164− const uint8_t kuiL2 = pRef[kiStride2-1];
165− const uint8_t kuiL3 = pRef[kiStride3-1];
162+ const uint8_t kuiL1 = pRef[kiStride - 1];
163+ const uint8_t kuiL2 = pRef[kiStride2 - 1];
164+ const uint8_t kuiL3 = pRef[kiStride3 - 1];
166165 const uint8_t kuiT0 = pRef[-kiStride];
167− const uint8_t kuiT1 = pRef[1-kiStride];
168− const uint8_t kuiT2 = pRef[2-kiStride];
169− const uint8_t kuiT3 = pRef[3-kiStride];
166+ const uint8_t kuiT1 = pRef[1 - kiStride];
167+ const uint8_t kuiT2 = pRef[2 - kiStride];
168+ const uint8_t kuiT3 = pRef[3 - kiStride];
170169 const uint16_t kuiTL0 = 1 + kuiLT + kuiL0;
171170 const uint16_t kuiLT0 = 1 + kuiLT + kuiT0;
172171 const uint16_t kuiT01 = 1 + kuiT0 + kuiT1;
@@ -182,21 +181,21 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredDDR) { · 9 unmodified lines
182181 const uint8_t kuiDDR4 = (kuiTL0 + kuiL01) >> 2;
183182 const uint8_t kuiDDR5 = (kuiL01 + kuiL12) >> 2;
184183 const uint8_t kuiDDR6 = (kuiL12 + kuiL23) >> 2;
185− ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
184+ ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
186185 uiV[0] = uiV[5] = uiV[10] = uiV[15] = kuiDDR0;
187186 uiV[1] = uiV[6] = uiV[11] = kuiDDR1;
188187 uiV[2] = uiV[7] = kuiDDR2;
189188 uiV[3] = kuiDDR3;
190189 uiV[4] = uiV[9] = uiV[14] = kuiDDR4;
191190 uiV[8] = uiV[13] = kuiDDR5;
192− uiV[12]= kuiDDR6;
191+ uiV[12] = kuiDDR6;
193192
194193 const uint32_t kuiCpuFlag = 0;
195− WelsInitFillingPredFuncs(kuiCpuFlag);
196− WelsI4x4LumaPredDDR_c(pPred, pRef, kiStride);
194+ WelsInitFillingPredFuncs (kuiCpuFlag);
195+ WelsI4x4LumaPredDDR_c (pPred, pRef, kiStride);
197196
198− for (int i=0; i<4; i++)
199− EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i]));
197+ for (int i = 0; i < 4; i++)
198+ EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
200199
201200 pRef -= kiStride + 1;
202201
@@ -204,94 +203,94 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredDDR) { · 1 unmodified line
204203 delete []pPred;
205204 }
206205
207−TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVL) {
206+TEST (GetIntraPredictorTest, TestGetI4x4LumaPredVL) {
208207 const int32_t kiStride = 0;
209208
210− uint8_t *pPred = new uint8_t[64];
211− uint8_t *pRef = new uint8_t[64];
212− for (int i=0; i<64; i++)
209+ uint8_t* pPred = new uint8_t[64];
210+ uint8_t* pRef = new uint8_t[64];
211+ for (int i = 0; i < 64; i++)
213212 pRef[i] = rand() % 256;
214213
215214 const uint8_t kuiT0 = pRef[-kiStride];
216− const uint8_t kuiT1 = pRef[1-kiStride];
217− const uint8_t kuiT2 = pRef[2-kiStride];
218− const uint8_t kuiT3 = pRef[3-kiStride];
219− const uint8_t kuiT4 = pRef[4-kiStride];
220− const uint8_t kuiT5 = pRef[5-kiStride];
221− const uint8_t kuiT6 = pRef[6-kiStride];
222− const uint8_t kuiVL0 = (1 + kuiT0 + kuiT1)>>1;
223− const uint8_t kuiVL1 = (1 + kuiT1 + kuiT2)>>1;
224− const uint8_t kuiVL2 = (1 + kuiT2 + kuiT3)>>1;
225− const uint8_t kuiVL3 = (1 + kuiT3 + kuiT4)>>1;
226− const uint8_t kuiVL4 = (1 + kuiT4 + kuiT5)>>1;
227− const uint8_t kuiVL5 = (2 + kuiT0 + (kuiT1<<1) + kuiT2)>>2;
228− const uint8_t kuiVL6 = (2 + kuiT1 + (kuiT2<<1) + kuiT3)>>2;
229− const uint8_t kuiVL7 = (2 + kuiT2 + (kuiT3<<1) + kuiT4)>>2;
230− const uint8_t kuiVL8 = (2 + kuiT3 + (kuiT4<<1) + kuiT5)>>2;
231− 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 follows
215+ const uint8_t kuiT1 = pRef[1 - kiStride];
216+ const uint8_t kuiT2 = pRef[2 - kiStride];
217+ const uint8_t kuiT3 = pRef[3 - kiStride];
218+ const uint8_t kuiT4 = pRef[4 - kiStride];
219+ const uint8_t kuiT5 = pRef[5 - kiStride];
220+ const uint8_t kuiT6 = pRef[6 - kiStride];
221+ const uint8_t kuiVL0 = (1 + kuiT0 + kuiT1) >> 1;
222+ const uint8_t kuiVL1 = (1 + kuiT1 + kuiT2) >> 1;
223+ const uint8_t kuiVL2 = (1 + kuiT2 + kuiT3) >> 1;
224+ const uint8_t kuiVL3 = (1 + kuiT3 + kuiT4) >> 1;
225+ const uint8_t kuiVL4 = (1 + kuiT4 + kuiT5) >> 1;
226+ const uint8_t kuiVL5 = (2 + kuiT0 + (kuiT1 << 1) + kuiT2) >> 2;
227+ const uint8_t kuiVL6 = (2 + kuiT1 + (kuiT2 << 1) + kuiT3) >> 2;
228+ const uint8_t kuiVL7 = (2 + kuiT2 + (kuiT3 << 1) + kuiT4) >> 2;
229+ const uint8_t kuiVL8 = (2 + kuiT3 + (kuiT4 << 1) + kuiT5) >> 2;
230+ const uint8_t kuiVL9 = (2 + kuiT4 + (kuiT5 << 1) + kuiT6) >> 2;
231+ ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
233232 uiV[0] = kuiVL0;
234233 uiV[1] = uiV[8] = kuiVL1;
235234 uiV[2] = uiV[9] = kuiVL2;
236− uiV[3] = uiV[10]= kuiVL3;
235+ uiV[3] = uiV[10] = kuiVL3;
237236 uiV[4] = kuiVL5;
238237 uiV[5] = uiV[12] = kuiVL6;
239238 uiV[6] = uiV[13] = kuiVL7;
240239 uiV[7] = uiV[14] = kuiVL8;
241− uiV[11]= kuiVL4;
242− uiV[15]= kuiVL9;
240+ uiV[11] = kuiVL4;
241+ uiV[15] = kuiVL9;
243242
244243 const uint32_t kuiCpuFlag = 0;
245− WelsInitFillingPredFuncs(kuiCpuFlag);
246− WelsI4x4LumaPredVL_c(pPred, pRef, kiStride);
244+ WelsInitFillingPredFuncs (kuiCpuFlag);
245+ WelsI4x4LumaPredVL_c (pPred, pRef, kiStride);
247246
248− for (int i=0; i<4; i++)
249− EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i]));
247+ for (int i = 0; i < 4; i++)
248+ EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
250249
251250 delete []pRef;
252251 delete []pPred;
253252 }
254253
255−TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVLTop) {
254+TEST (GetIntraPredictorTest, TestGetI4x4LumaPredVLTop) {
256255 const int32_t kiStride = 0;
257256
258− uint8_t *pPred = new uint8_t[64];
259− uint8_t *pRef = new uint8_t[64];
260− for (int i=0; i<64; i++)
257+ uint8_t* pPred = new uint8_t[64];
258+ uint8_t* pRef = new uint8_t[64];
259+ for (int i = 0; i < 64; i++)
261260 pRef[i] = rand() % 256;
262261
263262 pRef++;
264263
265− uint8_t *pTopLeft = &pRef[-kiStride-1]; // top-left
266−
267− const uint8_t kuiT0 = *(pTopLeft+1);
268− const uint8_t kuiT1 = *(pTopLeft+2);
269− const uint8_t kuiT2 = *(pTopLeft+3);
270− const uint8_t kuiT3 = *(pTopLeft+4);
271− const uint8_t kuiVLT0 = (1 + kuiT0 + kuiT1)>>1;
272− const uint8_t kuiVLT1 = (1 + kuiT1 + kuiT2)>>1;
273− const uint8_t kuiVLT2 = (1 + kuiT2 + kuiT3)>>1;
274− const uint8_t kuiVLT3 = (1 + (kuiT3<<1))>>1;
275− const uint8_t kuiVLT4 = (2 + kuiT0 + (kuiT1<<1) + kuiT2)>>2;
276− const uint8_t kuiVLT5 = (2 + kuiT1 + (kuiT2<<1) + kuiT3)>>2;
277− const uint8_t kuiVLT6 = (2 + kuiT2 + (kuiT3<<1) + kuiT3)>>2;
278− const uint8_t kuiVLT7 = (2 + (kuiT3<<2))>>2;
279− ENFORCE_STACK_ALIGN_1D(uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
264+ uint8_t* pTopLeft = &pRef[-kiStride - 1]; // top-left
265+
266+ const uint8_t kuiT0 = * (pTopLeft + 1);
267+ const uint8_t kuiT1 = * (pTopLeft + 2);
268+ const uint8_t kuiT2 = * (pTopLeft + 3);
269+ const uint8_t kuiT3 = * (pTopLeft + 4);
270+ const uint8_t kuiVLT0 = (1 + kuiT0 + kuiT1) >> 1;
271+ const uint8_t kuiVLT1 = (1 + kuiT1 + kuiT2) >> 1;
272+ const uint8_t kuiVLT2 = (1 + kuiT2 + kuiT3) >> 1;
273+ const uint8_t kuiVLT3 = (1 + (kuiT3 << 1)) >> 1;
274+ const uint8_t kuiVLT4 = (2 + kuiT0 + (kuiT1 << 1) + kuiT2) >> 2;
275+ const uint8_t kuiVLT5 = (2 + kuiT1 + (kuiT2 << 1) + kuiT3) >> 2;
276+ const uint8_t kuiVLT6 = (2 + kuiT2 + (kuiT3 << 1) + kuiT3) >> 2;
277+ const uint8_t kuiVLT7 = (2 + (kuiT3 << 2)) >> 2;
278+ ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
280279 uiV[0] = kuiVLT0;
281280 uiV[1] = uiV[8] = kuiVLT1;
282281 uiV[2] = uiV[9] = kuiVLT2;
283− uiV[3] = uiV[10]= uiV[11] = kuiVLT3;
282+ uiV[3] = uiV[10] = uiV[11] = kuiVLT3;
284283 uiV[4] = kuiVLT4;
285284 uiV[5] = uiV[12] = kuiVLT5;
286285 uiV[6] = uiV[13] = kuiVLT6;
287286 uiV[7] = uiV[14] = uiV[15] = kuiVLT7;
288287
289288 const uint32_t kuiCpuFlag = 0;
290− WelsInitFillingPredFuncs(kuiCpuFlag);
291− WelsI4x4LumaPredVLTop_c(pPred, pRef, kiStride);
289+ WelsInitFillingPredFuncs (kuiCpuFlag);
290+ WelsI4x4LumaPredVLTop_c (pPred, pRef, kiStride);
292291
293− for (int i=0; i<4; i++)
294− EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i]));
292+ for (int i = 0; i < 4; i++)
293+ EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
295294
296295 pRef--;
297296
@@ -299,26 +298,26 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVLTop) { · 1 unmodified line
299298 delete []pPred;
300299 }
301300
302−TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVR) {
303− const int32_t kiStride = rand()%256+16;
304− const int32_t kiStride2 = kiStride<<1;
301+TEST (GetIntraPredictorTest, TestGetI4x4LumaPredVR) {
302+ const int32_t kiStride = rand() % 256 + 16;
303+ const int32_t kiStride2 = kiStride << 1;
305304
306− uint8_t *pPred = new uint8_t[64];
307− uint8_t *pRef = new uint8_t[kiStride2+kiStride+1];
305+ uint8_t* pPred = new uint8_t[64];
306+ uint8_t* pRef = new uint8_t[kiStride2 + kiStride + 1];
308307
309− for (int i=0; i<kiStride2+kiStride+1; i++)
308+ for (int i = 0; i < kiStride2 + kiStride + 1; i++)
310309 pRef[i] = rand() % 256;
311310
312311 pRef += kiStride + 1;
313312
314− const uint8_t kuiLT = pRef[-kiStride-1]; // top-left
313+ const uint8_t kuiLT = pRef[-kiStride - 1]; // top-left
315314 const uint8_t kuiL0 = pRef[-1];
316− const uint8_t kuiL1 = pRef[kiStride-1];
317− const uint8_t kuiL2 = pRef[kiStride2-1];
315+ const uint8_t kuiL1 = pRef[kiStride - 1];
316+ const uint8_t kuiL2 = pRef[kiStride2 - 1];
318317 const uint8_t kuiT0 = pRef[-kiStride];
319− const uint8_t kuiT1 = pRef[1-kiStride];
320− const uint8_t kuiT2 = pRef[2-kiStride];
321− const uint8_t kuiT3 = pRef[3-kiStride];
318+ const uint8_t kuiT1 = pRef[1 - kiStride];
319+ const uint8_t kuiT2 = pRef[2 - kiStride];
320+ const uint8_t kuiT3 = pRef[3 - kiStride];
322321 const uint8_t kuiVR0 = (1 + kuiLT + kuiT0) >> 1;
323322 const uint8_t kuiVR1 = (1 + kuiT0 + kuiT1) >> 1;
324323 const uint8_t kuiVR2 = (1 + kuiT1 + kuiT2) >> 1;
@@ -329,7 +328,7 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVR) { · 4 unmodified lines
329328 const uint8_t kuiVR7 = (2 + kuiT1 + (kuiT2 << 1) + kuiT3) >> 2;
330329 const uint8_t kuiVR8 = (2 + kuiLT + (kuiL0 << 1) + kuiL1) >> 2;
331330 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 follows
331+ ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
333332 uiV[0] = uiV[9] = kuiVR0;
334333 uiV[1] = uiV[10] = kuiVR1;
335334 uiV[2] = uiV[11] = kuiVR2;
@@ -339,14 +338,14 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVR) { · 3 unmodified lines
339338 uiV[6] = uiV[15] = kuiVR6;
340339 uiV[7] = kuiVR7;
341340 uiV[8] = kuiVR8;
342− uiV[12]= kuiVR9;
341+ uiV[12] = kuiVR9;
343342
344343 const uint32_t kuiCpuFlag = 0;
345− WelsInitFillingPredFuncs(kuiCpuFlag);
346− WelsI4x4LumaPredVR_c(pPred, pRef, kiStride);
344+ WelsInitFillingPredFuncs (kuiCpuFlag);
345+ WelsI4x4LumaPredVR_c (pPred, pRef, kiStride);
347346
348− for (int i=0; i<4; i++)
349− EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i]));
347+ for (int i = 0; i < 4; i++)
348+ EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
350349
351350 pRef -= kiStride + 1;
352351
@@ -354,23 +353,23 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredVR) { · 1 unmodified line
354353 delete []pPred;
355354 }
356355
357−TEST(GetIntraPredictorTest, TestGetI4x4LumaPredHU) {
358− const int32_t kiStride = rand()%256+16;
359− const int32_t kiStride2 = kiStride<<1;
356+TEST (GetIntraPredictorTest, TestGetI4x4LumaPredHU) {
357+ const int32_t kiStride = rand() % 256 + 16;
358+ const int32_t kiStride2 = kiStride << 1;
360359 const int32_t kiStride3 = kiStride + kiStride2;
361360
362− uint8_t *pPred = new uint8_t[64];
363− uint8_t *pRef = new uint8_t[kiStride3+1];
361+ uint8_t* pPred = new uint8_t[64];
362+ uint8_t* pRef = new uint8_t[kiStride3 + 1];
364363
365− for (int i=0; i<kiStride3+1; i++)
364+ for (int i = 0; i < kiStride3 + 1; i++)
366365 pRef[i] = rand() % 256;
367366
368367 pRef++;
369368
370369 const uint8_t kuiL0 = pRef[-1];
371− const uint8_t kuiL1 = pRef[kiStride-1];
372− const uint8_t kuiL2 = pRef[kiStride2-1];
373− const uint8_t kuiL3 = pRef[kiStride3-1];
370+ const uint8_t kuiL1 = pRef[kiStride - 1];
371+ const uint8_t kuiL2 = pRef[kiStride2 - 1];
372+ const uint8_t kuiL3 = pRef[kiStride3 - 1];
374373 const uint16_t kuiL01 = (1 + kuiL0 + kuiL1);
375374 const uint16_t kuiL12 = (1 + kuiL1 + kuiL2);
376375 const uint16_t kuiL23 = (1 + kuiL2 + kuiL3);
@@ -380,21 +379,21 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredHU) { · 3 unmodified lines
380379 const uint8_t kuiHU3 = (kuiL12 + kuiL23) >> 2;
381380 const uint8_t kuiHU4 = kuiL23 >> 1;
382381 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 follows
382+ ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
384383 uiV[0] = kuiHU0;
385384 uiV[1] = kuiHU1;
386385 uiV[2] = uiV[4] = kuiHU2;
387386 uiV[3] = uiV[5] = kuiHU3;
388387 uiV[6] = uiV[8] = kuiHU4;
389388 uiV[7] = uiV[9] = kuiHU5;
390− memset(&uiV[10], kuiL3, 6*sizeof(uint8_t));
389+ memset (&uiV[10], kuiL3, 6 * sizeof (uint8_t));
391390
392391 const uint32_t kuiCpuFlag = 0;
393− WelsInitFillingPredFuncs(kuiCpuFlag);
394− WelsI4x4LumaPredHU_c(pPred, pRef, kiStride);
392+ WelsInitFillingPredFuncs (kuiCpuFlag);
393+ WelsI4x4LumaPredHU_c (pPred, pRef, kiStride);
395394
396− for (int i=0; i<4; i++)
397− EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i]));
395+ for (int i = 0; i < 4; i++)
396+ EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
398397
399398 pRef--;
400399
@@ -402,38 +401,38 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredHU) { · 1 unmodified line
402401 delete []pPred;
403402 }
404403
405−TEST(GetIntraPredictorTest, TestGetI4x4LumaPredHD) {
406− const int32_t kiStride = rand()%256+16;
407− const int32_t kiStride2 = kiStride<<1;
404+TEST (GetIntraPredictorTest, TestGetI4x4LumaPredHD) {
405+ const int32_t kiStride = rand() % 256 + 16;
406+ const int32_t kiStride2 = kiStride << 1;
408407 const int32_t kiStride3 = kiStride + kiStride2;
409408
410− uint8_t *pPred = new uint8_t[64];
411− uint8_t *pRef = new uint8_t[kiStride3+kiStride+1];
409+ uint8_t* pPred = new uint8_t[64];
410+ uint8_t* pRef = new uint8_t[kiStride3 + kiStride + 1];
412411
413− for (int i=0; i<kiStride3+kiStride+1; i++)
412+ for (int i = 0; i < kiStride3 + kiStride + 1; i++)
414413 pRef[i] = rand() % 256;
415414
416415 pRef += kiStride + 1;
417416
418− const uint8_t kuiLT = pRef[-kiStride-1]; // top-left
417+ const uint8_t kuiLT = pRef[-kiStride - 1]; // top-left
419418 const uint8_t kuiL0 = pRef[-1];
420− const uint8_t kuiL1 = pRef[kiStride-1];
421− const uint8_t kuiL2 = pRef[kiStride2-1];
422− const uint8_t kuiL3 = pRef[kiStride3-1];
419+ const uint8_t kuiL1 = pRef[kiStride - 1];
420+ const uint8_t kuiL2 = pRef[kiStride2 - 1];
421+ const uint8_t kuiL3 = pRef[kiStride3 - 1];
423422 const uint8_t kuiT0 = pRef[-kiStride];
424− const uint8_t kuiT1 = pRef[1-kiStride];
425− const uint8_t kuiT2 = pRef[2-kiStride];
426− const uint8_t kuiHD0 = (1 + kuiLT + kuiL0)>>1;
427− const uint8_t kuiHD1 = (2 + kuiL0 + (kuiLT<<1) + kuiT0)>>2;
428− const uint8_t kuiHD2 = (2 + kuiLT + (kuiT0<<1) + kuiT1)>>2;
429− const uint8_t kuiHD3 = (2 + kuiT0 + (kuiT1<<1) + kuiT2)>>2;
430− const uint8_t kuiHD4 = (1 + kuiL0 + kuiL1)>>1;
431− const uint8_t kuiHD5 = (2 + kuiLT + (kuiL0<<1) + kuiL1)>>2;
432− const uint8_t kuiHD6 = (1 + kuiL1 + kuiL2)>>1;
433− const uint8_t kuiHD7 = (2 + kuiL0 + (kuiL1<<1) + kuiL2)>>2;
434− const uint8_t kuiHD8 = (1 + kuiL2 + kuiL3)>>1;
435− 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 follows
423+ const uint8_t kuiT1 = pRef[1 - kiStride];
424+ const uint8_t kuiT2 = pRef[2 - kiStride];
425+ const uint8_t kuiHD0 = (1 + kuiLT + kuiL0) >> 1;
426+ const uint8_t kuiHD1 = (2 + kuiL0 + (kuiLT << 1) + kuiT0) >> 2;
427+ const uint8_t kuiHD2 = (2 + kuiLT + (kuiT0 << 1) + kuiT1) >> 2;
428+ const uint8_t kuiHD3 = (2 + kuiT0 + (kuiT1 << 1) + kuiT2) >> 2;
429+ const uint8_t kuiHD4 = (1 + kuiL0 + kuiL1) >> 1;
430+ const uint8_t kuiHD5 = (2 + kuiLT + (kuiL0 << 1) + kuiL1) >> 2;
431+ const uint8_t kuiHD6 = (1 + kuiL1 + kuiL2) >> 1;
432+ const uint8_t kuiHD7 = (2 + kuiL0 + (kuiL1 << 1) + kuiL2) >> 2;
433+ const uint8_t kuiHD8 = (1 + kuiL2 + kuiL3) >> 1;
434+ const uint8_t kuiHD9 = (2 + kuiL1 + (kuiL2 << 1) + kuiL3) >> 2;
435+ ENFORCE_STACK_ALIGN_1D (uint8_t, uiV, 16, 16) // TobeCont'd about assign opt as follows
437436 uiV[0] = uiV[6] = kuiHD0;
438437 uiV[1] = uiV[7] = kuiHD1;
439438 uiV[2] = kuiHD2;
@@ -446,11 +445,11 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredHD) { · 6 unmodified lines
446445 uiV[13] = kuiHD9;
447446
448447 const uint32_t kuiCpuFlag = 0;
449− WelsInitFillingPredFuncs(kuiCpuFlag);
450− WelsI4x4LumaPredHD_c(pPred, pRef, kiStride);
448+ WelsInitFillingPredFuncs (kuiCpuFlag);
449+ WelsI4x4LumaPredHD_c (pPred, pRef, kiStride);
451450
452− for (int i=0; i<4; i++)
453− EXPECT_EQ(LD32(&pPred[4*i]),LD32(&uiV[4*i]));
451+ for (int i = 0; i < 4; i++)
452+ EXPECT_EQ (LD32 (&pPred[4 * i]), LD32 (&uiV[4 * i]));
454453
455454 pRef -= kiStride + 1;
456455
@@ -458,52 +457,52 @@ TEST(GetIntraPredictorTest, TestGetI4x4LumaPredHD) { · 1 unmodified line
458457 delete []pPred;
459458 }
460459
461−TEST(GetIntraPredictorTest, TestGetIChormaPredV) {
462− uint8_t *pPred = new uint8_t[64];
463− uint8_t *pRef = new uint8_t[64];
464− for (int i=0; i<64; i++)
460+TEST (GetIntraPredictorTest, TestGetIChormaPredV) {
461+ uint8_t* pPred = new uint8_t[64];
462+ uint8_t* pRef = new uint8_t[64];
463+ for (int i = 0; i < 64; i++)
465464 pRef[i] = rand() % 256 + 1;
466465
467466 const int32_t kiStride = 0;
468− WelsIChormaPredV_c(pPred, pRef, kiStride);
467+ WelsIChormaPredV_c (pPred, pRef, kiStride);
469468
470− for (int i=0; i<8; i++)
471− EXPECT_EQ(LD32(&pPred[8*i]),LD32(&pRef[-kiStride]));
469+ for (int i = 0; i < 8; i++)
470+ EXPECT_EQ (LD32 (&pPred[8 * i]), LD32 (&pRef[-kiStride]));
472471
473472 delete []pRef;
474473 delete []pPred;
475474 }
476475
477−TEST(GetIntraPredictorTest, TestGetI16x16LumaPredPlane) {
478− const int32_t kiStride = rand()%16+16;
476+TEST (GetIntraPredictorTest, TestGetI16x16LumaPredPlane) {
477+ const int32_t kiStride = rand() % 16 + 16;
479478
480479 int32_t i, j;
481480
482− uint8_t *pPred = new uint8_t[16*kiStride];
483− uint8_t *pRef = new uint8_t[16*kiStride+1];
484− for (i=0; i<16*kiStride+1; i++)
485− pRef[i]=rand()%256+1;
481+ uint8_t* pPred = new uint8_t[16 * kiStride];
482+ uint8_t* pRef = new uint8_t[16 * kiStride + 1];
483+ for (i = 0; i < 16 * kiStride + 1; i++)
484+ pRef[i] = rand() % 256 + 1;
486485
487486 pRef += kiStride + 1;
488487
489− int32_t iA=0, iB=0, iC=0, iH=0, iV=0;
490− uint8_t *pTop = &pRef[-kiStride];
491− uint8_t *pLeft = &pRef[-1];
488+ int32_t iA = 0, iB = 0, iC = 0, iH = 0, iV = 0;
489+ uint8_t* pTop = &pRef[-kiStride];
490+ uint8_t* pLeft = &pRef[-1];
492491 int32_t iPredStride = 16;
493492
494− for (i=0; i<8; i++) {
493+ for (i = 0; i < 8; i++) {
495494 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]);
497496 }
498497
499− iA = (pLeft[15*kiStride] + pTop[15]) << 4;
498+ iA = (pLeft[15 * kiStride] + pTop[15]) << 4;
500499 iB = (5 * iH + 32) >> 6;
501500 iC = (5 * iV + 32) >> 6;
502501
503− WelsI16x16LumaPredPlane_c(pPred, pRef, kiStride);
504− for (i=0; i<16; i++) {
505− for (j=0; j<16; j++) {
506− EXPECT_EQ(pPred[j],(uint8_t)WelsClip1((iA + iB * (j - 7) + iC * (i - 7) + 16) >> 5));
502+ WelsI16x16LumaPredPlane_c (pPred, pRef, kiStride);
503+ for (i = 0; i < 16; i++) {
504+ for (j = 0; j < 16; j++) {
505+ EXPECT_EQ (pPred[j], (uint8_t)WelsClip1 ((iA + iB * (j - 7) + iC * (i - 7) + 16) >> 5));
507506 }
508507 pPred += iPredStride;
509508 }
@@ -514,14 +513,14 @@ TEST(GetIntraPredictorTest, TestGetI16x16LumaPredPlane) { · 4 unmodified lines
514513 delete []pPred;
515514 }
516515
517−TEST(GetIntraPredictorTest, TestGetI16x16LumaPredDc) {
518− const int32_t kiStride = rand()%16+16;
516+TEST (GetIntraPredictorTest, TestGetI16x16LumaPredDc) {
517+ const int32_t kiStride = rand() % 16 + 16;
519518
520519 int i;
521520
522− uint8_t *pPred = new uint8_t[256];
523− uint8_t *pRef = new uint8_t[16*kiStride];
524− for (i=0; i<16*kiStride; i++)
521+ uint8_t* pPred = new uint8_t[256];
522+ uint8_t* pRef = new uint8_t[16 * kiStride];
523+ for (i = 0; i < 16 * kiStride; i++)
525524 pRef[i] = rand() % 256 + 1;
526525
527526 pRef += kiStride;
@@ -532,14 +531,14 @@ TEST(GetIntraPredictorTest, TestGetI16x16LumaPredDc) { · 4 unmodified lines
532531 uint8_t uiMean = 0;
533532
534533 do {
535− iSum += pRef[-1+iTmp] + pRef[-kiStride+i];
534+ iSum += pRef[-1 + iTmp] + pRef[-kiStride + i];
536535 iTmp -= kiStride;
537− } while(i-- > 0);
538− uiMean = ( 16 + iSum ) >> 5;
536+ } while (i-- > 0);
537+ uiMean = (16 + iSum) >> 5;
539538
540− WelsI16x16LumaPredDc_c(pPred, pRef, kiStride);
541− for (i=0; i<256; i++)
542− EXPECT_EQ(pPred[i],uiMean);
539+ WelsI16x16LumaPredDc_c (pPred, pRef, kiStride);
540+ for (i = 0; i < 256; i++)
541+ EXPECT_EQ (pPred[i], uiMean);
543542
544543 pRef -= kiStride;
545544
@@ -547,14 +546,14 @@ TEST(GetIntraPredictorTest, TestGetI16x16LumaPredDc) { · 1 unmodified line
547546 delete []pPred;
548547 }
549548
550−TEST(GetIntraPredictorTest, TestGetI16x16LumaPredDcTop) {
551− const int32_t kiStride = rand()%16+16;
549+TEST (GetIntraPredictorTest, TestGetI16x16LumaPredDcTop) {
550+ const int32_t kiStride = rand() % 16 + 16;
552551
553552 int i;
554553
555− uint8_t *pPred = new uint8_t[256];
556− uint8_t *pRef = new uint8_t[16*kiStride];
557− for (i=0; i<16*kiStride; i++)
554+ uint8_t* pPred = new uint8_t[256];
555+ uint8_t* pRef = new uint8_t[16 * kiStride];
556+ for (i = 0; i < 16 * kiStride; i++)
558557 pRef[i] = rand() % 256 + 1;
559558
560559 pRef += kiStride;
@@ -563,13 +562,13 @@ TEST(GetIntraPredictorTest, TestGetI16x16LumaPredDcTop) { · 2 unmodified lines
563562 i = 15;
564563 uint8_t uiMean = 0;
565564 do {
566− iSum += pRef[-kiStride+i];
567− } while(i-- > 0);
568− uiMean = ( 8 + iSum ) >> 4;
565+ iSum += pRef[-kiStride + i];
566+ } while (i-- > 0);
567+ uiMean = (8 + iSum) >> 4;
569568
570− WelsI16x16LumaPredDcTop_c(pPred, pRef, kiStride);
571− for (i=0; i<256; i++)
572− EXPECT_EQ(pPred[i],uiMean);
569+ WelsI16x16LumaPredDcTop_c (pPred, pRef, kiStride);
570+ for (i = 0; i < 256; i++)
571+ EXPECT_EQ (pPred[i], uiMean);
573572
574573 pRef -= kiStride;
575574

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