1 // Copyright 2011 Google Inc.
2 //
3 // This code is licensed under the same terms as WebM:
4 // Software License Agreement: http://www.webmproject.org/license/software/
5 // Additional IP Rights Grant: http://www.webmproject.org/license/additional/
6 // -----------------------------------------------------------------------------
7 //
8 // SSE2 version of dsp functions and loop filtering.
9 //
10 // Author: somnath@google.com (Somnath Banerjee)
11 // cduvivier@google.com (Christian Duvivier)
12
13 #if defined(__SSE2__) || defined(_MSC_VER)
14
15 #include <emmintrin.h>
16 #include "vp8i.h"
17
18 #if defined(__cplusplus) || defined(c_plusplus)
19 extern "C" {
20 #endif
21
22 //-----------------------------------------------------------------------------
23 // Transforms (Paragraph 14.4)
24
TransformSSE2(const int16_t * in,uint8_t * dst,int do_two)25 static void TransformSSE2(const int16_t* in, uint8_t* dst, int do_two) {
26 // This implementation makes use of 16-bit fixed point versions of two
27 // multiply constants:
28 // K1 = sqrt(2) * cos (pi/8) ~= 85627 / 2^16
29 // K2 = sqrt(2) * sin (pi/8) ~= 35468 / 2^16
30 //
31 // To be able to use signed 16-bit integers, we use the following trick to
32 // have constants within range:
33 // - Associated constants are obtained by subtracting the 16-bit fixed point
34 // version of one:
35 // k = K - (1 << 16) => K = k + (1 << 16)
36 // K1 = 85267 => k1 = 20091
37 // K2 = 35468 => k2 = -30068
38 // - The multiplication of a variable by a constant become the sum of the
39 // variable and the multiplication of that variable by the associated
40 // constant:
41 // (x * K) >> 16 = (x * (k + (1 << 16))) >> 16 = ((x * k ) >> 16) + x
42 const __m128i k1 = _mm_set1_epi16(20091);
43 const __m128i k2 = _mm_set1_epi16(-30068);
44 __m128i T0, T1, T2, T3;
45
46 // Load and concatenate the transform coefficients (we'll do two transforms
47 // in parallel). In the case of only one transform, the second half of the
48 // vectors will just contain random value we'll never use nor store.
49 __m128i in0, in1, in2, in3;
50 {
51 in0 = _mm_loadl_epi64((__m128i*)&in[0]);
52 in1 = _mm_loadl_epi64((__m128i*)&in[4]);
53 in2 = _mm_loadl_epi64((__m128i*)&in[8]);
54 in3 = _mm_loadl_epi64((__m128i*)&in[12]);
55 // a00 a10 a20 a30 x x x x
56 // a01 a11 a21 a31 x x x x
57 // a02 a12 a22 a32 x x x x
58 // a03 a13 a23 a33 x x x x
59 if (do_two) {
60 const __m128i inB0 = _mm_loadl_epi64((__m128i*)&in[16]);
61 const __m128i inB1 = _mm_loadl_epi64((__m128i*)&in[20]);
62 const __m128i inB2 = _mm_loadl_epi64((__m128i*)&in[24]);
63 const __m128i inB3 = _mm_loadl_epi64((__m128i*)&in[28]);
64 in0 = _mm_unpacklo_epi64(in0, inB0);
65 in1 = _mm_unpacklo_epi64(in1, inB1);
66 in2 = _mm_unpacklo_epi64(in2, inB2);
67 in3 = _mm_unpacklo_epi64(in3, inB3);
68 // a00 a10 a20 a30 b00 b10 b20 b30
69 // a01 a11 a21 a31 b01 b11 b21 b31
70 // a02 a12 a22 a32 b02 b12 b22 b32
71 // a03 a13 a23 a33 b03 b13 b23 b33
72 }
73 }
74
75 // Vertical pass and subsequent transpose.
76 {
77 // First pass, c and d calculations are longer because of the "trick"
78 // multiplications.
79 const __m128i a = _mm_add_epi16(in0, in2);
80 const __m128i b = _mm_sub_epi16(in0, in2);
81 // c = MUL(in1, K2) - MUL(in3, K1) = MUL(in1, k2) - MUL(in3, k1) + in1 - in3
82 const __m128i c1 = _mm_mulhi_epi16(in1, k2);
83 const __m128i c2 = _mm_mulhi_epi16(in3, k1);
84 const __m128i c3 = _mm_sub_epi16(in1, in3);
85 const __m128i c4 = _mm_sub_epi16(c1, c2);
86 const __m128i c = _mm_add_epi16(c3, c4);
87 // d = MUL(in1, K1) + MUL(in3, K2) = MUL(in1, k1) + MUL(in3, k2) + in1 + in3
88 const __m128i d1 = _mm_mulhi_epi16(in1, k1);
89 const __m128i d2 = _mm_mulhi_epi16(in3, k2);
90 const __m128i d3 = _mm_add_epi16(in1, in3);
91 const __m128i d4 = _mm_add_epi16(d1, d2);
92 const __m128i d = _mm_add_epi16(d3, d4);
93
94 // Second pass.
95 const __m128i tmp0 = _mm_add_epi16(a, d);
96 const __m128i tmp1 = _mm_add_epi16(b, c);
97 const __m128i tmp2 = _mm_sub_epi16(b, c);
98 const __m128i tmp3 = _mm_sub_epi16(a, d);
99
100 // Transpose the two 4x4.
101 // a00 a01 a02 a03 b00 b01 b02 b03
102 // a10 a11 a12 a13 b10 b11 b12 b13
103 // a20 a21 a22 a23 b20 b21 b22 b23
104 // a30 a31 a32 a33 b30 b31 b32 b33
105 const __m128i transpose0_0 = _mm_unpacklo_epi16(tmp0, tmp1);
106 const __m128i transpose0_1 = _mm_unpacklo_epi16(tmp2, tmp3);
107 const __m128i transpose0_2 = _mm_unpackhi_epi16(tmp0, tmp1);
108 const __m128i transpose0_3 = _mm_unpackhi_epi16(tmp2, tmp3);
109 // a00 a10 a01 a11 a02 a12 a03 a13
110 // a20 a30 a21 a31 a22 a32 a23 a33
111 // b00 b10 b01 b11 b02 b12 b03 b13
112 // b20 b30 b21 b31 b22 b32 b23 b33
113 const __m128i transpose1_0 = _mm_unpacklo_epi32(transpose0_0, transpose0_1);
114 const __m128i transpose1_1 = _mm_unpacklo_epi32(transpose0_2, transpose0_3);
115 const __m128i transpose1_2 = _mm_unpackhi_epi32(transpose0_0, transpose0_1);
116 const __m128i transpose1_3 = _mm_unpackhi_epi32(transpose0_2, transpose0_3);
117 // a00 a10 a20 a30 a01 a11 a21 a31
118 // b00 b10 b20 b30 b01 b11 b21 b31
119 // a02 a12 a22 a32 a03 a13 a23 a33
120 // b02 b12 a22 b32 b03 b13 b23 b33
121 T0 = _mm_unpacklo_epi64(transpose1_0, transpose1_1);
122 T1 = _mm_unpackhi_epi64(transpose1_0, transpose1_1);
123 T2 = _mm_unpacklo_epi64(transpose1_2, transpose1_3);
124 T3 = _mm_unpackhi_epi64(transpose1_2, transpose1_3);
125 // a00 a10 a20 a30 b00 b10 b20 b30
126 // a01 a11 a21 a31 b01 b11 b21 b31
127 // a02 a12 a22 a32 b02 b12 b22 b32
128 // a03 a13 a23 a33 b03 b13 b23 b33
129 }
130
131 // Horizontal pass and subsequent transpose.
132 {
133 // First pass, c and d calculations are longer because of the "trick"
134 // multiplications.
135 const __m128i four = _mm_set1_epi16(4);
136 const __m128i dc = _mm_add_epi16(T0, four);
137 const __m128i a = _mm_add_epi16(dc, T2);
138 const __m128i b = _mm_sub_epi16(dc, T2);
139 // c = MUL(T1, K2) - MUL(T3, K1) = MUL(T1, k2) - MUL(T3, k1) + T1 - T3
140 const __m128i c1 = _mm_mulhi_epi16(T1, k2);
141 const __m128i c2 = _mm_mulhi_epi16(T3, k1);
142 const __m128i c3 = _mm_sub_epi16(T1, T3);
143 const __m128i c4 = _mm_sub_epi16(c1, c2);
144 const __m128i c = _mm_add_epi16(c3, c4);
145 // d = MUL(T1, K1) + MUL(T3, K2) = MUL(T1, k1) + MUL(T3, k2) + T1 + T3
146 const __m128i d1 = _mm_mulhi_epi16(T1, k1);
147 const __m128i d2 = _mm_mulhi_epi16(T3, k2);
148 const __m128i d3 = _mm_add_epi16(T1, T3);
149 const __m128i d4 = _mm_add_epi16(d1, d2);
150 const __m128i d = _mm_add_epi16(d3, d4);
151
152 // Second pass.
153 const __m128i tmp0 = _mm_add_epi16(a, d);
154 const __m128i tmp1 = _mm_add_epi16(b, c);
155 const __m128i tmp2 = _mm_sub_epi16(b, c);
156 const __m128i tmp3 = _mm_sub_epi16(a, d);
157 const __m128i shifted0 = _mm_srai_epi16(tmp0, 3);
158 const __m128i shifted1 = _mm_srai_epi16(tmp1, 3);
159 const __m128i shifted2 = _mm_srai_epi16(tmp2, 3);
160 const __m128i shifted3 = _mm_srai_epi16(tmp3, 3);
161
162 // Transpose the two 4x4.
163 // a00 a01 a02 a03 b00 b01 b02 b03
164 // a10 a11 a12 a13 b10 b11 b12 b13
165 // a20 a21 a22 a23 b20 b21 b22 b23
166 // a30 a31 a32 a33 b30 b31 b32 b33
167 const __m128i transpose0_0 = _mm_unpacklo_epi16(shifted0, shifted1);
168 const __m128i transpose0_1 = _mm_unpacklo_epi16(shifted2, shifted3);
169 const __m128i transpose0_2 = _mm_unpackhi_epi16(shifted0, shifted1);
170 const __m128i transpose0_3 = _mm_unpackhi_epi16(shifted2, shifted3);
171 // a00 a10 a01 a11 a02 a12 a03 a13
172 // a20 a30 a21 a31 a22 a32 a23 a33
173 // b00 b10 b01 b11 b02 b12 b03 b13
174 // b20 b30 b21 b31 b22 b32 b23 b33
175 const __m128i transpose1_0 = _mm_unpacklo_epi32(transpose0_0, transpose0_1);
176 const __m128i transpose1_1 = _mm_unpacklo_epi32(transpose0_2, transpose0_3);
177 const __m128i transpose1_2 = _mm_unpackhi_epi32(transpose0_0, transpose0_1);
178 const __m128i transpose1_3 = _mm_unpackhi_epi32(transpose0_2, transpose0_3);
179 // a00 a10 a20 a30 a01 a11 a21 a31
180 // b00 b10 b20 b30 b01 b11 b21 b31
181 // a02 a12 a22 a32 a03 a13 a23 a33
182 // b02 b12 a22 b32 b03 b13 b23 b33
183 T0 = _mm_unpacklo_epi64(transpose1_0, transpose1_1);
184 T1 = _mm_unpackhi_epi64(transpose1_0, transpose1_1);
185 T2 = _mm_unpacklo_epi64(transpose1_2, transpose1_3);
186 T3 = _mm_unpackhi_epi64(transpose1_2, transpose1_3);
187 // a00 a10 a20 a30 b00 b10 b20 b30
188 // a01 a11 a21 a31 b01 b11 b21 b31
189 // a02 a12 a22 a32 b02 b12 b22 b32
190 // a03 a13 a23 a33 b03 b13 b23 b33
191 }
192
193 // Add inverse transform to 'dst' and store.
194 {
195 const __m128i zero = _mm_set1_epi16(0);
196 // Load the reference(s).
197 __m128i dst0, dst1, dst2, dst3;
198 if (do_two) {
199 // Load eight bytes/pixels per line.
200 dst0 = _mm_loadl_epi64((__m128i*)&dst[0 * BPS]);
201 dst1 = _mm_loadl_epi64((__m128i*)&dst[1 * BPS]);
202 dst2 = _mm_loadl_epi64((__m128i*)&dst[2 * BPS]);
203 dst3 = _mm_loadl_epi64((__m128i*)&dst[3 * BPS]);
204 } else {
205 // Load four bytes/pixels per line.
206 dst0 = _mm_cvtsi32_si128(*(int*)&dst[0 * BPS]);
207 dst1 = _mm_cvtsi32_si128(*(int*)&dst[1 * BPS]);
208 dst2 = _mm_cvtsi32_si128(*(int*)&dst[2 * BPS]);
209 dst3 = _mm_cvtsi32_si128(*(int*)&dst[3 * BPS]);
210 }
211 // Convert to 16b.
212 dst0 = _mm_unpacklo_epi8(dst0, zero);
213 dst1 = _mm_unpacklo_epi8(dst1, zero);
214 dst2 = _mm_unpacklo_epi8(dst2, zero);
215 dst3 = _mm_unpacklo_epi8(dst3, zero);
216 // Add the inverse transform(s).
217 dst0 = _mm_add_epi16(dst0, T0);
218 dst1 = _mm_add_epi16(dst1, T1);
219 dst2 = _mm_add_epi16(dst2, T2);
220 dst3 = _mm_add_epi16(dst3, T3);
221 // Unsigned saturate to 8b.
222 dst0 = _mm_packus_epi16(dst0, dst0);
223 dst1 = _mm_packus_epi16(dst1, dst1);
224 dst2 = _mm_packus_epi16(dst2, dst2);
225 dst3 = _mm_packus_epi16(dst3, dst3);
226 // Store the results.
227 if (do_two) {
228 // Store eight bytes/pixels per line.
229 _mm_storel_epi64((__m128i*)&dst[0 * BPS], dst0);
230 _mm_storel_epi64((__m128i*)&dst[1 * BPS], dst1);
231 _mm_storel_epi64((__m128i*)&dst[2 * BPS], dst2);
232 _mm_storel_epi64((__m128i*)&dst[3 * BPS], dst3);
233 } else {
234 // Store four bytes/pixels per line.
235 *((int32_t *)&dst[0 * BPS]) = _mm_cvtsi128_si32(dst0);
236 *((int32_t *)&dst[1 * BPS]) = _mm_cvtsi128_si32(dst1);
237 *((int32_t *)&dst[2 * BPS]) = _mm_cvtsi128_si32(dst2);
238 *((int32_t *)&dst[3 * BPS]) = _mm_cvtsi128_si32(dst3);
239 }
240 }
241 }
242
243 //-----------------------------------------------------------------------------
244 // Loop Filter (Paragraph 15)
245
246 // Compute abs(p - q) = subs(p - q) OR subs(q - p)
247 #define MM_ABS(p, q) _mm_or_si128( \
248 _mm_subs_epu8((q), (p)), \
249 _mm_subs_epu8((p), (q)))
250
251 // Shift each byte of "a" by N bits while preserving by the sign bit.
252 //
253 // It first shifts the lower bytes of the words and then the upper bytes and
254 // then merges the results together.
255 #define SIGNED_SHIFT_N(a, N) { \
256 __m128i t = a; \
257 t = _mm_slli_epi16(t, 8); \
258 t = _mm_srai_epi16(t, N); \
259 t = _mm_srli_epi16(t, 8); \
260 \
261 a = _mm_srai_epi16(a, N + 8); \
262 a = _mm_slli_epi16(a, 8); \
263 \
264 a = _mm_or_si128(t, a); \
265 }
266
267 #define FLIP_SIGN_BIT2(a, b) { \
268 a = _mm_xor_si128(a, sign_bit); \
269 b = _mm_xor_si128(b, sign_bit); \
270 }
271
272 #define FLIP_SIGN_BIT4(a, b, c, d) { \
273 FLIP_SIGN_BIT2(a, b); \
274 FLIP_SIGN_BIT2(c, d); \
275 }
276
277 #define GET_NOTHEV(p1, p0, q0, q1, hev_thresh, not_hev) { \
278 const __m128i zero = _mm_setzero_si128(); \
279 const __m128i t1 = MM_ABS(p1, p0); \
280 const __m128i t2 = MM_ABS(q1, q0); \
281 \
282 const __m128i h = _mm_set1_epi8(hev_thresh); \
283 const __m128i t3 = _mm_subs_epu8(t1, h); /* abs(p1 - p0) - hev_tresh */ \
284 const __m128i t4 = _mm_subs_epu8(t2, h); /* abs(q1 - q0) - hev_tresh */ \
285 \
286 not_hev = _mm_or_si128(t3, t4); \
287 not_hev = _mm_cmpeq_epi8(not_hev, zero); /* not_hev <= t1 && not_hev <= t2 */\
288 }
289
290 #define GET_BASE_DELTA(p1, p0, q0, q1, o) { \
291 const __m128i qp0 = _mm_subs_epi8(q0, p0); /* q0 - p0 */ \
292 o = _mm_subs_epi8(p1, q1); /* p1 - q1 */ \
293 o = _mm_adds_epi8(o, qp0); /* p1 - q1 + 1 * (q0 - p0) */ \
294 o = _mm_adds_epi8(o, qp0); /* p1 - q1 + 2 * (q0 - p0) */ \
295 o = _mm_adds_epi8(o, qp0); /* p1 - q1 + 3 * (q0 - p0) */ \
296 }
297
298 #define DO_SIMPLE_FILTER(p0, q0, fl) { \
299 const __m128i three = _mm_set1_epi8(3); \
300 const __m128i four = _mm_set1_epi8(4); \
301 __m128i v3 = _mm_adds_epi8(fl, three); \
302 __m128i v4 = _mm_adds_epi8(fl, four); \
303 \
304 /* Do +4 side */ \
305 SIGNED_SHIFT_N(v4, 3); /* v4 >> 3 */ \
306 q0 = _mm_subs_epi8(q0, v4); /* q0 -= v4 */ \
307 \
308 /* Now do +3 side */ \
309 SIGNED_SHIFT_N(v3, 3); /* v3 >> 3 */ \
310 p0 = _mm_adds_epi8(p0, v3); /* p0 += v3 */ \
311 }
312
313 // Updates values of 2 pixels at MB edge during complex filtering.
314 // Update operations:
315 // q = q - a and p = p + a; where a = [(a_hi >> 7), (a_lo >> 7)]
316 #define UPDATE_2PIXELS(pi, qi, a_lo, a_hi) { \
317 const __m128i a_lo7 = _mm_srai_epi16(a_lo, 7); \
318 const __m128i a_hi7 = _mm_srai_epi16(a_hi, 7); \
319 const __m128i a = _mm_packs_epi16(a_lo7, a_hi7); \
320 pi = _mm_adds_epi8(pi, a); \
321 qi = _mm_subs_epi8(qi, a); \
322 }
323
NeedsFilter(const __m128i * p1,const __m128i * p0,const __m128i * q0,const __m128i * q1,int thresh,__m128i * mask)324 static void NeedsFilter(const __m128i* p1, const __m128i* p0, const __m128i* q0,
325 const __m128i* q1, int thresh, __m128i *mask) {
326 __m128i t1 = MM_ABS(*p1, *q1); // abs(p1 - q1)
327 *mask = _mm_set1_epi8(0xFE);
328 t1 = _mm_and_si128(t1, *mask); // set lsb of each byte to zero
329 t1 = _mm_srli_epi16(t1, 1); // abs(p1 - q1) / 2
330
331 *mask = MM_ABS(*p0, *q0); // abs(p0 - q0)
332 *mask = _mm_adds_epu8(*mask, *mask); // abs(p0 - q0) * 2
333 *mask = _mm_adds_epu8(*mask, t1); // abs(p0 - q0) * 2 + abs(p1 - q1) / 2
334
335 t1 = _mm_set1_epi8(thresh);
336 *mask = _mm_subs_epu8(*mask, t1); // mask <= thresh
337 *mask = _mm_cmpeq_epi8(*mask, _mm_setzero_si128());
338 }
339
340 //-----------------------------------------------------------------------------
341 // Edge filtering functions
342
343 // Applies filter on 2 pixels (p0 and q0)
DoFilter2(const __m128i * p1,__m128i * p0,__m128i * q0,const __m128i * q1,int thresh)344 static inline void DoFilter2(const __m128i* p1, __m128i* p0, __m128i* q0,
345 const __m128i* q1, int thresh) {
346 __m128i a, mask;
347 const __m128i sign_bit = _mm_set1_epi8(0x80);
348 const __m128i p1s = _mm_xor_si128(*p1, sign_bit);
349 const __m128i q1s = _mm_xor_si128(*q1, sign_bit);
350
351 NeedsFilter(p1, p0, q0, q1, thresh, &mask);
352
353 // convert to signed values
354 FLIP_SIGN_BIT2(*p0, *q0);
355
356 GET_BASE_DELTA(p1s, *p0, *q0, q1s, a);
357 a = _mm_and_si128(a, mask); // mask filter values we don't care about
358 DO_SIMPLE_FILTER(*p0, *q0, a);
359
360 // unoffset
361 FLIP_SIGN_BIT2(*p0, *q0);
362 }
363
364 // Applies filter on 4 pixels (p1, p0, q0 and q1)
DoFilter4(__m128i * p1,__m128i * p0,__m128i * q0,__m128i * q1,const __m128i * mask,int hev_thresh)365 static inline void DoFilter4(__m128i* p1, __m128i *p0, __m128i* q0, __m128i* q1,
366 const __m128i* mask, int hev_thresh) {
367 __m128i not_hev;
368 __m128i t1, t2, t3;
369 const __m128i sign_bit = _mm_set1_epi8(0x80);
370
371 // compute hev mask
372 GET_NOTHEV(*p1, *p0, *q0, *q1, hev_thresh, not_hev);
373
374 // convert to signed values
375 FLIP_SIGN_BIT4(*p1, *p0, *q0, *q1);
376
377 t1 = _mm_subs_epi8(*p1, *q1); // p1 - q1
378 t1 = _mm_andnot_si128(not_hev, t1); // hev(p1 - q1)
379 t2 = _mm_subs_epi8(*q0, *p0); // q0 - p0
380 t1 = _mm_adds_epi8(t1, t2); // hev(p1 - q1) + 1 * (q0 - p0)
381 t1 = _mm_adds_epi8(t1, t2); // hev(p1 - q1) + 2 * (q0 - p0)
382 t1 = _mm_adds_epi8(t1, t2); // hev(p1 - q1) + 3 * (q0 - p0)
383 t1 = _mm_and_si128(t1, *mask); // mask filter values we don't care about
384
385 // Do +4 side
386 t2 = _mm_set1_epi8(4);
387 t2 = _mm_adds_epi8(t1, t2); // 3 * (q0 - p0) + (p1 - q1) + 4
388 SIGNED_SHIFT_N(t2, 3); // (3 * (q0 - p0) + hev(p1 - q1) + 4) >> 3
389 t3 = t2; // save t2
390 *q0 = _mm_subs_epi8(*q0, t2); // q0 -= t2
391
392 // Now do +3 side
393 t2 = _mm_set1_epi8(3);
394 t2 = _mm_adds_epi8(t1, t2); // +3 instead of +4
395 SIGNED_SHIFT_N(t2, 3); // (3 * (q0 - p0) + hev(p1 - q1) + 3) >> 3
396 *p0 = _mm_adds_epi8(*p0, t2); // p0 += t2
397
398 t2 = _mm_set1_epi8(1);
399 t3 = _mm_adds_epi8(t3, t2);
400 SIGNED_SHIFT_N(t3, 1); // (3 * (q0 - p0) + hev(p1 - q1) + 4) >> 4
401
402 t3 = _mm_and_si128(not_hev, t3); // if !hev
403 *q1 = _mm_subs_epi8(*q1, t3); // q1 -= t3
404 *p1 = _mm_adds_epi8(*p1, t3); // p1 += t3
405
406 // unoffset
407 FLIP_SIGN_BIT4(*p1, *p0, *q0, *q1);
408 }
409
410 // Applies filter on 6 pixels (p2, p1, p0, q0, q1 and q2)
DoFilter6(__m128i * p2,__m128i * p1,__m128i * p0,__m128i * q0,__m128i * q1,__m128i * q2,const __m128i * mask,int hev_thresh)411 static inline void DoFilter6(__m128i *p2, __m128i* p1, __m128i *p0,
412 __m128i* q0, __m128i* q1, __m128i *q2,
413 const __m128i* mask, int hev_thresh) {
414 __m128i a, not_hev;
415 const __m128i sign_bit = _mm_set1_epi8(0x80);
416
417 // compute hev mask
418 GET_NOTHEV(*p1, *p0, *q0, *q1, hev_thresh, not_hev);
419
420 // convert to signed values
421 FLIP_SIGN_BIT4(*p1, *p0, *q0, *q1);
422 FLIP_SIGN_BIT2(*p2, *q2);
423
424 GET_BASE_DELTA(*p1, *p0, *q0, *q1, a);
425
426 { // do simple filter on pixels with hev
427 const __m128i m = _mm_andnot_si128(not_hev, *mask);
428 const __m128i f = _mm_and_si128(a, m);
429 DO_SIMPLE_FILTER(*p0, *q0, f);
430 }
431 { // do strong filter on pixels with not hev
432 const __m128i zero = _mm_setzero_si128();
433 const __m128i nine = _mm_set1_epi16(0x0900);
434 const __m128i sixty_three = _mm_set1_epi16(63);
435
436 const __m128i m = _mm_and_si128(not_hev, *mask);
437 const __m128i f = _mm_and_si128(a, m);
438 const __m128i f_lo = _mm_unpacklo_epi8(zero, f);
439 const __m128i f_hi = _mm_unpackhi_epi8(zero, f);
440
441 const __m128i f9_lo = _mm_mulhi_epi16(f_lo, nine); // Filter (lo) * 9
442 const __m128i f9_hi = _mm_mulhi_epi16(f_hi, nine); // Filter (hi) * 9
443 const __m128i f18_lo = _mm_add_epi16(f9_lo, f9_lo); // Filter (lo) * 18
444 const __m128i f18_hi = _mm_add_epi16(f9_hi, f9_hi); // Filter (hi) * 18
445
446 const __m128i a2_lo = _mm_add_epi16(f9_lo, sixty_three); // Filter * 9 + 63
447 const __m128i a2_hi = _mm_add_epi16(f9_hi, sixty_three); // Filter * 9 + 63
448
449 const __m128i a1_lo = _mm_add_epi16(f18_lo, sixty_three); // F... * 18 + 63
450 const __m128i a1_hi = _mm_add_epi16(f18_hi, sixty_three); // F... * 18 + 63
451
452 const __m128i a0_lo = _mm_add_epi16(f18_lo, a2_lo); // Filter * 27 + 63
453 const __m128i a0_hi = _mm_add_epi16(f18_hi, a2_hi); // Filter * 27 + 63
454
455 UPDATE_2PIXELS(*p2, *q2, a2_lo, a2_hi);
456 UPDATE_2PIXELS(*p1, *q1, a1_lo, a1_hi);
457 UPDATE_2PIXELS(*p0, *q0, a0_lo, a0_hi);
458 }
459
460 // unoffset
461 FLIP_SIGN_BIT4(*p1, *p0, *q0, *q1);
462 FLIP_SIGN_BIT2(*p2, *q2);
463 }
464
465 // reads 8 rows across a vertical edge.
466 //
467 // TODO(somnath): Investigate _mm_shuffle* also see if it can be broken into
468 // two Load4x4() to avoid code duplication.
Load8x4(const uint8_t * b,int stride,__m128i * p,__m128i * q)469 static inline void Load8x4(const uint8_t* b, int stride,
470 __m128i* p, __m128i* q) {
471 __m128i t1, t2;
472
473 // Load 0th, 1st, 4th and 5th rows
474 __m128i r0 = _mm_cvtsi32_si128(*((int*)&b[0 * stride])); // 03 02 01 00
475 __m128i r1 = _mm_cvtsi32_si128(*((int*)&b[1 * stride])); // 13 12 11 10
476 __m128i r4 = _mm_cvtsi32_si128(*((int*)&b[4 * stride])); // 43 42 41 40
477 __m128i r5 = _mm_cvtsi32_si128(*((int*)&b[5 * stride])); // 53 52 51 50
478
479 r0 = _mm_unpacklo_epi32(r0, r4); // 43 42 41 40 03 02 01 00
480 r1 = _mm_unpacklo_epi32(r1, r5); // 53 52 51 50 13 12 11 10
481
482 // t1 = 53 43 52 42 51 41 50 40 13 03 12 02 11 01 10 00
483 t1 = _mm_unpacklo_epi8(r0, r1);
484
485 // Load 2nd, 3rd, 6th and 7th rows
486 r0 = _mm_cvtsi32_si128(*((int*)&b[2 * stride])); // 23 22 21 22
487 r1 = _mm_cvtsi32_si128(*((int*)&b[3 * stride])); // 33 32 31 30
488 r4 = _mm_cvtsi32_si128(*((int*)&b[6 * stride])); // 63 62 61 60
489 r5 = _mm_cvtsi32_si128(*((int*)&b[7 * stride])); // 73 72 71 70
490
491 r0 = _mm_unpacklo_epi32(r0, r4); // 63 62 61 60 23 22 21 20
492 r1 = _mm_unpacklo_epi32(r1, r5); // 73 72 71 70 33 32 31 30
493
494 // t2 = 73 63 72 62 71 61 70 60 33 23 32 22 31 21 30 20
495 t2 = _mm_unpacklo_epi8(r0, r1);
496
497 // t1 = 33 23 13 03 32 22 12 02 31 21 11 01 30 20 10 00
498 // t2 = 73 63 53 43 72 62 52 42 71 61 51 41 70 60 50 40
499 r0 = t1;
500 t1 = _mm_unpacklo_epi16(t1, t2);
501 t2 = _mm_unpackhi_epi16(r0, t2);
502
503 // *p = 71 61 51 41 31 21 11 01 70 60 50 40 30 20 10 00
504 // *q = 73 63 53 43 33 23 13 03 72 62 52 42 32 22 12 02
505 *p = _mm_unpacklo_epi32(t1, t2);
506 *q = _mm_unpackhi_epi32(t1, t2);
507 }
508
Load16x4(const uint8_t * r0,const uint8_t * r8,int stride,__m128i * p1,__m128i * p0,__m128i * q0,__m128i * q1)509 static inline void Load16x4(const uint8_t* r0, const uint8_t* r8, int stride,
510 __m128i* p1, __m128i* p0,
511 __m128i* q0, __m128i* q1) {
512 __m128i t1, t2;
513 // Assume the pixels around the edge (|) are numbered as follows
514 // 00 01 | 02 03
515 // 10 11 | 12 13
516 // ... | ...
517 // e0 e1 | e2 e3
518 // f0 f1 | f2 f3
519 //
520 // r0 is pointing to the 0th row (00)
521 // r8 is pointing to the 8th row (80)
522
523 // Load
524 // p1 = 71 61 51 41 31 21 11 01 70 60 50 40 30 20 10 00
525 // q0 = 73 63 53 43 33 23 13 03 72 62 52 42 32 22 12 02
526 // p0 = f1 e1 d1 c1 b1 a1 91 81 f0 e0 d0 c0 b0 a0 90 80
527 // q1 = f3 e3 d3 c3 b3 a3 93 83 f2 e2 d2 c2 b2 a2 92 82
528 Load8x4(r0, stride, p1, q0);
529 Load8x4(r8, stride, p0, q1);
530
531 t1 = *p1;
532 t2 = *q0;
533 // p1 = f0 e0 d0 c0 b0 a0 90 80 70 60 50 40 30 20 10 00
534 // p0 = f1 e1 d1 c1 b1 a1 91 81 71 61 51 41 31 21 11 01
535 // q0 = f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02
536 // q1 = f3 e3 d3 c3 b3 a3 93 83 73 63 53 43 33 23 13 03
537 *p1 = _mm_unpacklo_epi64(t1, *p0);
538 *p0 = _mm_unpackhi_epi64(t1, *p0);
539 *q0 = _mm_unpacklo_epi64(t2, *q1);
540 *q1 = _mm_unpackhi_epi64(t2, *q1);
541 }
542
Store4x4(__m128i * x,uint8_t * dst,int stride)543 static inline void Store4x4(__m128i* x, uint8_t* dst, int stride) {
544 int i;
545 for (i = 0; i < 4; ++i, dst += stride) {
546 *((int32_t*)dst) = _mm_cvtsi128_si32(*x);
547 *x = _mm_srli_si128(*x, 4);
548 }
549 }
550
551 // Transpose back and store
Store16x4(uint8_t * r0,uint8_t * r8,int stride,__m128i * p1,__m128i * p0,__m128i * q0,__m128i * q1)552 static inline void Store16x4(uint8_t* r0, uint8_t* r8, int stride, __m128i* p1,
553 __m128i* p0, __m128i* q0, __m128i* q1) {
554 __m128i t1;
555
556 // p0 = 71 70 61 60 51 50 41 40 31 30 21 20 11 10 01 00
557 // p1 = f1 f0 e1 e0 d1 d0 c1 c0 b1 b0 a1 a0 91 90 81 80
558 t1 = *p0;
559 *p0 = _mm_unpacklo_epi8(*p1, t1);
560 *p1 = _mm_unpackhi_epi8(*p1, t1);
561
562 // q0 = 73 72 63 62 53 52 43 42 33 32 23 22 13 12 03 02
563 // q1 = f3 f2 e3 e2 d3 d2 c3 c2 b3 b2 a3 a2 93 92 83 82
564 t1 = *q0;
565 *q0 = _mm_unpacklo_epi8(t1, *q1);
566 *q1 = _mm_unpackhi_epi8(t1, *q1);
567
568 // p0 = 33 32 31 30 23 22 21 20 13 12 11 10 03 02 01 00
569 // q0 = 73 72 71 70 63 62 61 60 53 52 51 50 43 42 41 40
570 t1 = *p0;
571 *p0 = _mm_unpacklo_epi16(t1, *q0);
572 *q0 = _mm_unpackhi_epi16(t1, *q0);
573
574 // p1 = b3 b2 b1 b0 a3 a2 a1 a0 93 92 91 90 83 82 81 80
575 // q1 = f3 f2 f1 f0 e3 e2 e1 e0 d3 d2 d1 d0 c3 c2 c1 c0
576 t1 = *p1;
577 *p1 = _mm_unpacklo_epi16(t1, *q1);
578 *q1 = _mm_unpackhi_epi16(t1, *q1);
579
580 Store4x4(p0, r0, stride);
581 r0 += 4 * stride;
582 Store4x4(q0, r0, stride);
583
584 Store4x4(p1, r8, stride);
585 r8 += 4 * stride;
586 Store4x4(q1, r8, stride);
587 }
588
589 //-----------------------------------------------------------------------------
590 // Simple In-loop filtering (Paragraph 15.2)
591
SimpleVFilter16SSE2(uint8_t * p,int stride,int thresh)592 static void SimpleVFilter16SSE2(uint8_t* p, int stride, int thresh) {
593 // Load
594 __m128i p1 = _mm_loadu_si128((__m128i*)&p[-2 * stride]);
595 __m128i p0 = _mm_loadu_si128((__m128i*)&p[-stride]);
596 __m128i q0 = _mm_loadu_si128((__m128i*)&p[0]);
597 __m128i q1 = _mm_loadu_si128((__m128i*)&p[stride]);
598
599 DoFilter2(&p1, &p0, &q0, &q1, thresh);
600
601 // Store
602 _mm_storeu_si128((__m128i*)&p[-stride], p0);
603 _mm_storeu_si128((__m128i*)p, q0);
604 }
605
SimpleHFilter16SSE2(uint8_t * p,int stride,int thresh)606 static void SimpleHFilter16SSE2(uint8_t* p, int stride, int thresh) {
607 __m128i p1, p0, q0, q1;
608
609 p -= 2; // beginning of p1
610
611 Load16x4(p, p + 8 * stride, stride, &p1, &p0, &q0, &q1);
612 DoFilter2(&p1, &p0, &q0, &q1, thresh);
613 Store16x4(p, p + 8 * stride, stride, &p1, &p0, &q0, &q1);
614 }
615
SimpleVFilter16iSSE2(uint8_t * p,int stride,int thresh)616 static void SimpleVFilter16iSSE2(uint8_t* p, int stride, int thresh) {
617 int k;
618 for (k = 3; k > 0; --k) {
619 p += 4 * stride;
620 SimpleVFilter16SSE2(p, stride, thresh);
621 }
622 }
623
SimpleHFilter16iSSE2(uint8_t * p,int stride,int thresh)624 static void SimpleHFilter16iSSE2(uint8_t* p, int stride, int thresh) {
625 int k;
626 for (k = 3; k > 0; --k) {
627 p += 4;
628 SimpleHFilter16SSE2(p, stride, thresh);
629 }
630 }
631
632 //-----------------------------------------------------------------------------
633 // Complex In-loop filtering (Paragraph 15.3)
634
635 #define MAX_DIFF1(p3, p2, p1, p0, m) { \
636 m = MM_ABS(p3, p2); \
637 m = _mm_max_epu8(m, MM_ABS(p2, p1)); \
638 m = _mm_max_epu8(m, MM_ABS(p1, p0)); \
639 }
640
641 #define MAX_DIFF2(p3, p2, p1, p0, m) { \
642 m = _mm_max_epu8(m, MM_ABS(p3, p2)); \
643 m = _mm_max_epu8(m, MM_ABS(p2, p1)); \
644 m = _mm_max_epu8(m, MM_ABS(p1, p0)); \
645 }
646
647 #define LOAD_H_EDGES4(p, stride, e1, e2, e3, e4) { \
648 e1 = _mm_loadu_si128((__m128i*)&(p)[0 * stride]); \
649 e2 = _mm_loadu_si128((__m128i*)&(p)[1 * stride]); \
650 e3 = _mm_loadu_si128((__m128i*)&(p)[2 * stride]); \
651 e4 = _mm_loadu_si128((__m128i*)&(p)[3 * stride]); \
652 }
653
654 #define LOADUV_H_EDGE(p, u, v, stride) { \
655 p = _mm_loadl_epi64((__m128i*)&(u)[(stride)]); \
656 p = _mm_unpacklo_epi64(p, _mm_loadl_epi64((__m128i*)&(v)[(stride)])); \
657 }
658
659 #define LOADUV_H_EDGES4(u, v, stride, e1, e2, e3, e4) { \
660 LOADUV_H_EDGE(e1, u, v, 0 * stride); \
661 LOADUV_H_EDGE(e2, u, v, 1 * stride); \
662 LOADUV_H_EDGE(e3, u, v, 2 * stride); \
663 LOADUV_H_EDGE(e4, u, v, 3 * stride); \
664 }
665
666 #define STOREUV(p, u, v, stride) { \
667 _mm_storel_epi64((__m128i*)&u[(stride)], p); \
668 p = _mm_srli_si128(p, 8); \
669 _mm_storel_epi64((__m128i*)&v[(stride)], p); \
670 }
671
672 #define COMPLEX_FL_MASK(p1, p0, q0, q1, thresh, ithresh, mask) { \
673 __m128i fl_yes; \
674 const __m128i it = _mm_set1_epi8(ithresh); \
675 mask = _mm_subs_epu8(mask, it); \
676 mask = _mm_cmpeq_epi8(mask, _mm_setzero_si128()); \
677 NeedsFilter(&p1, &p0, &q0, &q1, thresh, &fl_yes); \
678 mask = _mm_and_si128(mask, fl_yes); \
679 }
680
681 // on macroblock edges
VFilter16SSE2(uint8_t * p,int stride,int thresh,int ithresh,int hev_thresh)682 static void VFilter16SSE2(uint8_t* p, int stride,
683 int thresh, int ithresh, int hev_thresh) {
684 __m128i t1;
685 __m128i mask;
686 __m128i p2, p1, p0, q0, q1, q2;
687
688 // Load p3, p2, p1, p0
689 LOAD_H_EDGES4(p - 4 * stride, stride, t1, p2, p1, p0);
690 MAX_DIFF1(t1, p2, p1, p0, mask);
691
692 // Load q0, q1, q2, q3
693 LOAD_H_EDGES4(p, stride, q0, q1, q2, t1);
694 MAX_DIFF2(t1, q2, q1, q0, mask);
695
696 COMPLEX_FL_MASK(p1, p0, q0, q1, thresh, ithresh, mask);
697 DoFilter6(&p2, &p1, &p0, &q0, &q1, &q2, &mask, hev_thresh);
698
699 // Store
700 _mm_storeu_si128((__m128i*)&p[-3 * stride], p2);
701 _mm_storeu_si128((__m128i*)&p[-2 * stride], p1);
702 _mm_storeu_si128((__m128i*)&p[-1 * stride], p0);
703 _mm_storeu_si128((__m128i*)&p[0 * stride], q0);
704 _mm_storeu_si128((__m128i*)&p[1 * stride], q1);
705 _mm_storeu_si128((__m128i*)&p[2 * stride], q2);
706 }
707
HFilter16SSE2(uint8_t * p,int stride,int thresh,int ithresh,int hev_thresh)708 static void HFilter16SSE2(uint8_t* p, int stride,
709 int thresh, int ithresh, int hev_thresh) {
710 __m128i mask;
711 __m128i p3, p2, p1, p0, q0, q1, q2, q3;
712
713 uint8_t* const b = p - 4;
714 Load16x4(b, b + 8 * stride, stride, &p3, &p2, &p1, &p0); // p3, p2, p1, p0
715 MAX_DIFF1(p3, p2, p1, p0, mask);
716
717 Load16x4(p, p + 8 * stride, stride, &q0, &q1, &q2, &q3); // q0, q1, q2, q3
718 MAX_DIFF2(q3, q2, q1, q0, mask);
719
720 COMPLEX_FL_MASK(p1, p0, q0, q1, thresh, ithresh, mask);
721 DoFilter6(&p2, &p1, &p0, &q0, &q1, &q2, &mask, hev_thresh);
722
723 Store16x4(b, b + 8 * stride, stride, &p3, &p2, &p1, &p0);
724 Store16x4(p, p + 8 * stride, stride, &q0, &q1, &q2, &q3);
725 }
726
727 // on three inner edges
VFilter16iSSE2(uint8_t * p,int stride,int thresh,int ithresh,int hev_thresh)728 static void VFilter16iSSE2(uint8_t* p, int stride,
729 int thresh, int ithresh, int hev_thresh) {
730 int k;
731 __m128i mask;
732 __m128i t1, t2, p1, p0, q0, q1;
733
734 for (k = 3; k > 0; --k) {
735 // Load p3, p2, p1, p0
736 LOAD_H_EDGES4(p, stride, t2, t1, p1, p0);
737 MAX_DIFF1(t2, t1, p1, p0, mask);
738
739 p += 4 * stride;
740
741 // Load q0, q1, q2, q3
742 LOAD_H_EDGES4(p, stride, q0, q1, t1, t2);
743 MAX_DIFF2(t2, t1, q1, q0, mask);
744
745 COMPLEX_FL_MASK(p1, p0, q0, q1, thresh, ithresh, mask);
746 DoFilter4(&p1, &p0, &q0, &q1, &mask, hev_thresh);
747
748 // Store
749 _mm_storeu_si128((__m128i*)&p[-2 * stride], p1);
750 _mm_storeu_si128((__m128i*)&p[-1 * stride], p0);
751 _mm_storeu_si128((__m128i*)&p[0 * stride], q0);
752 _mm_storeu_si128((__m128i*)&p[1 * stride], q1);
753 }
754 }
755
HFilter16iSSE2(uint8_t * p,int stride,int thresh,int ithresh,int hev_thresh)756 static void HFilter16iSSE2(uint8_t* p, int stride,
757 int thresh, int ithresh, int hev_thresh) {
758 int k;
759 uint8_t* b;
760 __m128i mask;
761 __m128i t1, t2, p1, p0, q0, q1;
762
763 for (k = 3; k > 0; --k) {
764 b = p;
765 Load16x4(b, b + 8 * stride, stride, &t2, &t1, &p1, &p0); // p3, p2, p1, p0
766 MAX_DIFF1(t2, t1, p1, p0, mask);
767
768 b += 4; // beginning of q0
769 Load16x4(b, b + 8 * stride, stride, &q0, &q1, &t1, &t2); // q0, q1, q2, q3
770 MAX_DIFF2(t2, t1, q1, q0, mask);
771
772 COMPLEX_FL_MASK(p1, p0, q0, q1, thresh, ithresh, mask);
773 DoFilter4(&p1, &p0, &q0, &q1, &mask, hev_thresh);
774
775 b -= 2; // beginning of p1
776 Store16x4(b, b + 8 * stride, stride, &p1, &p0, &q0, &q1);
777
778 p += 4;
779 }
780 }
781
782 // 8-pixels wide variant, for chroma filtering
VFilter8SSE2(uint8_t * u,uint8_t * v,int stride,int thresh,int ithresh,int hev_thresh)783 static void VFilter8SSE2(uint8_t* u, uint8_t* v, int stride,
784 int thresh, int ithresh, int hev_thresh) {
785 __m128i mask;
786 __m128i t1, p2, p1, p0, q0, q1, q2;
787
788 // Load p3, p2, p1, p0
789 LOADUV_H_EDGES4(u - 4 * stride, v - 4 * stride, stride, t1, p2, p1, p0);
790 MAX_DIFF1(t1, p2, p1, p0, mask);
791
792 // Load q0, q1, q2, q3
793 LOADUV_H_EDGES4(u, v, stride, q0, q1, q2, t1);
794 MAX_DIFF2(t1, q2, q1, q0, mask);
795
796 COMPLEX_FL_MASK(p1, p0, q0, q1, thresh, ithresh, mask);
797 DoFilter6(&p2, &p1, &p0, &q0, &q1, &q2, &mask, hev_thresh);
798
799 // Store
800 STOREUV(p2, u, v, -3 * stride);
801 STOREUV(p1, u, v, -2 * stride);
802 STOREUV(p0, u, v, -1 * stride);
803 STOREUV(q0, u, v, 0 * stride);
804 STOREUV(q1, u, v, 1 * stride);
805 STOREUV(q2, u, v, 2 * stride);
806 }
807
HFilter8SSE2(uint8_t * u,uint8_t * v,int stride,int thresh,int ithresh,int hev_thresh)808 static void HFilter8SSE2(uint8_t* u, uint8_t* v, int stride,
809 int thresh, int ithresh, int hev_thresh) {
810 __m128i mask;
811 __m128i p3, p2, p1, p0, q0, q1, q2, q3;
812
813 uint8_t* const tu = u - 4;
814 uint8_t* const tv = v - 4;
815 Load16x4(tu, tv, stride, &p3, &p2, &p1, &p0); // p3, p2, p1, p0
816 MAX_DIFF1(p3, p2, p1, p0, mask);
817
818 Load16x4(u, v, stride, &q0, &q1, &q2, &q3); // q0, q1, q2, q3
819 MAX_DIFF2(q3, q2, q1, q0, mask);
820
821 COMPLEX_FL_MASK(p1, p0, q0, q1, thresh, ithresh, mask);
822 DoFilter6(&p2, &p1, &p0, &q0, &q1, &q2, &mask, hev_thresh);
823
824 Store16x4(tu, tv, stride, &p3, &p2, &p1, &p0);
825 Store16x4(u, v, stride, &q0, &q1, &q2, &q3);
826 }
827
VFilter8iSSE2(uint8_t * u,uint8_t * v,int stride,int thresh,int ithresh,int hev_thresh)828 static void VFilter8iSSE2(uint8_t* u, uint8_t* v, int stride,
829 int thresh, int ithresh, int hev_thresh) {
830 __m128i mask;
831 __m128i t1, t2, p1, p0, q0, q1;
832
833 // Load p3, p2, p1, p0
834 LOADUV_H_EDGES4(u, v, stride, t2, t1, p1, p0);
835 MAX_DIFF1(t2, t1, p1, p0, mask);
836
837 u += 4 * stride;
838 v += 4 * stride;
839
840 // Load q0, q1, q2, q3
841 LOADUV_H_EDGES4(u, v, stride, q0, q1, t1, t2);
842 MAX_DIFF2(t2, t1, q1, q0, mask);
843
844 COMPLEX_FL_MASK(p1, p0, q0, q1, thresh, ithresh, mask);
845 DoFilter4(&p1, &p0, &q0, &q1, &mask, hev_thresh);
846
847 // Store
848 STOREUV(p1, u, v, -2 * stride);
849 STOREUV(p0, u, v, -1 * stride);
850 STOREUV(q0, u, v, 0 * stride);
851 STOREUV(q1, u, v, 1 * stride);
852 }
853
HFilter8iSSE2(uint8_t * u,uint8_t * v,int stride,int thresh,int ithresh,int hev_thresh)854 static void HFilter8iSSE2(uint8_t* u, uint8_t* v, int stride,
855 int thresh, int ithresh, int hev_thresh) {
856 __m128i mask;
857 __m128i t1, t2, p1, p0, q0, q1;
858 Load16x4(u, v, stride, &t2, &t1, &p1, &p0); // p3, p2, p1, p0
859 MAX_DIFF1(t2, t1, p1, p0, mask);
860
861 u += 4; // beginning of q0
862 v += 4;
863 Load16x4(u, v, stride, &q0, &q1, &t1, &t2); // q0, q1, q2, q3
864 MAX_DIFF2(t2, t1, q1, q0, mask);
865
866 COMPLEX_FL_MASK(p1, p0, q0, q1, thresh, ithresh, mask);
867 DoFilter4(&p1, &p0, &q0, &q1, &mask, hev_thresh);
868
869 u -= 2; // beginning of p1
870 v -= 2;
871 Store16x4(u, v, stride, &p1, &p0, &q0, &q1);
872 }
873
874 extern void VP8DspInitSSE2(void);
875
VP8DspInitSSE2(void)876 void VP8DspInitSSE2(void) {
877 VP8Transform = TransformSSE2;
878
879 VP8VFilter16 = VFilter16SSE2;
880 VP8HFilter16 = HFilter16SSE2;
881 VP8VFilter8 = VFilter8SSE2;
882 VP8HFilter8 = HFilter8SSE2;
883 VP8VFilter16i = VFilter16iSSE2;
884 VP8HFilter16i = HFilter16iSSE2;
885 VP8VFilter8i = VFilter8iSSE2;
886 VP8HFilter8i = HFilter8iSSE2;
887
888 VP8SimpleVFilter16 = SimpleVFilter16SSE2;
889 VP8SimpleHFilter16 = SimpleHFilter16SSE2;
890 VP8SimpleVFilter16i = SimpleVFilter16iSSE2;
891 VP8SimpleHFilter16i = SimpleHFilter16iSSE2;
892 }
893
894 #if defined(__cplusplus) || defined(c_plusplus)
895 } // extern "C"
896 #endif
897
898 #endif //__SSE2__ || _MSC_VER
899