• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2011 Google Inc. All Rights Reserved.
2 //
3 // Use of this source code is governed by a BSD-style license
4 // that can be found in the COPYING file in the root of the source
5 // tree. An additional intellectual property rights grant can be found
6 // in the file PATENTS. All contributing project authors may
7 // be found in the AUTHORS file in the root of the source tree.
8 // -----------------------------------------------------------------------------
9 //
10 // SSE2 version of some decoding functions (idct, loop filtering).
11 //
12 // Author: somnath@google.com (Somnath Banerjee)
13 //         cduvivier@google.com (Christian Duvivier)
14 
15 #include "src/dsp/dsp.h"
16 
17 #if defined(WEBP_USE_SSE2)
18 
19 // The 3-coeff sparse transform in SSE2 is not really faster than the plain-C
20 // one it seems => disable it by default. Uncomment the following to enable:
21 #if !defined(USE_TRANSFORM_AC3)
22 #define USE_TRANSFORM_AC3 0   // ALTERNATE_CODE
23 #endif
24 
25 #include <emmintrin.h>
26 #include "src/dsp/common_sse2.h"
27 #include "src/dec/vp8i_dec.h"
28 #include "src/utils/utils.h"
29 
30 //------------------------------------------------------------------------------
31 // Transforms (Paragraph 14.4)
32 
Transform_SSE2(const int16_t * in,uint8_t * dst,int do_two)33 static void Transform_SSE2(const int16_t* in, uint8_t* dst, int do_two) {
34   // This implementation makes use of 16-bit fixed point versions of two
35   // multiply constants:
36   //    K1 = sqrt(2) * cos (pi/8) ~= 85627 / 2^16
37   //    K2 = sqrt(2) * sin (pi/8) ~= 35468 / 2^16
38   //
39   // To be able to use signed 16-bit integers, we use the following trick to
40   // have constants within range:
41   // - Associated constants are obtained by subtracting the 16-bit fixed point
42   //   version of one:
43   //      k = K - (1 << 16)  =>  K = k + (1 << 16)
44   //      K1 = 85267  =>  k1 =  20091
45   //      K2 = 35468  =>  k2 = -30068
46   // - The multiplication of a variable by a constant become the sum of the
47   //   variable and the multiplication of that variable by the associated
48   //   constant:
49   //      (x * K) >> 16 = (x * (k + (1 << 16))) >> 16 = ((x * k ) >> 16) + x
50   const __m128i k1 = _mm_set1_epi16(20091);
51   const __m128i k2 = _mm_set1_epi16(-30068);
52   __m128i T0, T1, T2, T3;
53 
54   // Load and concatenate the transform coefficients (we'll do two transforms
55   // in parallel). In the case of only one transform, the second half of the
56   // vectors will just contain random value we'll never use nor store.
57   __m128i in0, in1, in2, in3;
58   {
59     in0 = _mm_loadl_epi64((const __m128i*)&in[0]);
60     in1 = _mm_loadl_epi64((const __m128i*)&in[4]);
61     in2 = _mm_loadl_epi64((const __m128i*)&in[8]);
62     in3 = _mm_loadl_epi64((const __m128i*)&in[12]);
63     // a00 a10 a20 a30   x x x x
64     // a01 a11 a21 a31   x x x x
65     // a02 a12 a22 a32   x x x x
66     // a03 a13 a23 a33   x x x x
67     if (do_two) {
68       const __m128i inB0 = _mm_loadl_epi64((const __m128i*)&in[16]);
69       const __m128i inB1 = _mm_loadl_epi64((const __m128i*)&in[20]);
70       const __m128i inB2 = _mm_loadl_epi64((const __m128i*)&in[24]);
71       const __m128i inB3 = _mm_loadl_epi64((const __m128i*)&in[28]);
72       in0 = _mm_unpacklo_epi64(in0, inB0);
73       in1 = _mm_unpacklo_epi64(in1, inB1);
74       in2 = _mm_unpacklo_epi64(in2, inB2);
75       in3 = _mm_unpacklo_epi64(in3, inB3);
76       // a00 a10 a20 a30   b00 b10 b20 b30
77       // a01 a11 a21 a31   b01 b11 b21 b31
78       // a02 a12 a22 a32   b02 b12 b22 b32
79       // a03 a13 a23 a33   b03 b13 b23 b33
80     }
81   }
82 
83   // Vertical pass and subsequent transpose.
84   {
85     // First pass, c and d calculations are longer because of the "trick"
86     // multiplications.
87     const __m128i a = _mm_add_epi16(in0, in2);
88     const __m128i b = _mm_sub_epi16(in0, in2);
89     // c = MUL(in1, K2) - MUL(in3, K1) = MUL(in1, k2) - MUL(in3, k1) + in1 - in3
90     const __m128i c1 = _mm_mulhi_epi16(in1, k2);
91     const __m128i c2 = _mm_mulhi_epi16(in3, k1);
92     const __m128i c3 = _mm_sub_epi16(in1, in3);
93     const __m128i c4 = _mm_sub_epi16(c1, c2);
94     const __m128i c = _mm_add_epi16(c3, c4);
95     // d = MUL(in1, K1) + MUL(in3, K2) = MUL(in1, k1) + MUL(in3, k2) + in1 + in3
96     const __m128i d1 = _mm_mulhi_epi16(in1, k1);
97     const __m128i d2 = _mm_mulhi_epi16(in3, k2);
98     const __m128i d3 = _mm_add_epi16(in1, in3);
99     const __m128i d4 = _mm_add_epi16(d1, d2);
100     const __m128i d = _mm_add_epi16(d3, d4);
101 
102     // Second pass.
103     const __m128i tmp0 = _mm_add_epi16(a, d);
104     const __m128i tmp1 = _mm_add_epi16(b, c);
105     const __m128i tmp2 = _mm_sub_epi16(b, c);
106     const __m128i tmp3 = _mm_sub_epi16(a, d);
107 
108     // Transpose the two 4x4.
109     VP8Transpose_2_4x4_16b(&tmp0, &tmp1, &tmp2, &tmp3, &T0, &T1, &T2, &T3);
110   }
111 
112   // Horizontal pass and subsequent transpose.
113   {
114     // First pass, c and d calculations are longer because of the "trick"
115     // multiplications.
116     const __m128i four = _mm_set1_epi16(4);
117     const __m128i dc = _mm_add_epi16(T0, four);
118     const __m128i a =  _mm_add_epi16(dc, T2);
119     const __m128i b =  _mm_sub_epi16(dc, T2);
120     // c = MUL(T1, K2) - MUL(T3, K1) = MUL(T1, k2) - MUL(T3, k1) + T1 - T3
121     const __m128i c1 = _mm_mulhi_epi16(T1, k2);
122     const __m128i c2 = _mm_mulhi_epi16(T3, k1);
123     const __m128i c3 = _mm_sub_epi16(T1, T3);
124     const __m128i c4 = _mm_sub_epi16(c1, c2);
125     const __m128i c = _mm_add_epi16(c3, c4);
126     // d = MUL(T1, K1) + MUL(T3, K2) = MUL(T1, k1) + MUL(T3, k2) + T1 + T3
127     const __m128i d1 = _mm_mulhi_epi16(T1, k1);
128     const __m128i d2 = _mm_mulhi_epi16(T3, k2);
129     const __m128i d3 = _mm_add_epi16(T1, T3);
130     const __m128i d4 = _mm_add_epi16(d1, d2);
131     const __m128i d = _mm_add_epi16(d3, d4);
132 
133     // Second pass.
134     const __m128i tmp0 = _mm_add_epi16(a, d);
135     const __m128i tmp1 = _mm_add_epi16(b, c);
136     const __m128i tmp2 = _mm_sub_epi16(b, c);
137     const __m128i tmp3 = _mm_sub_epi16(a, d);
138     const __m128i shifted0 = _mm_srai_epi16(tmp0, 3);
139     const __m128i shifted1 = _mm_srai_epi16(tmp1, 3);
140     const __m128i shifted2 = _mm_srai_epi16(tmp2, 3);
141     const __m128i shifted3 = _mm_srai_epi16(tmp3, 3);
142 
143     // Transpose the two 4x4.
144     VP8Transpose_2_4x4_16b(&shifted0, &shifted1, &shifted2, &shifted3, &T0, &T1,
145                            &T2, &T3);
146   }
147 
148   // Add inverse transform to 'dst' and store.
149   {
150     const __m128i zero = _mm_setzero_si128();
151     // Load the reference(s).
152     __m128i dst0, dst1, dst2, dst3;
153     if (do_two) {
154       // Load eight bytes/pixels per line.
155       dst0 = _mm_loadl_epi64((__m128i*)(dst + 0 * BPS));
156       dst1 = _mm_loadl_epi64((__m128i*)(dst + 1 * BPS));
157       dst2 = _mm_loadl_epi64((__m128i*)(dst + 2 * BPS));
158       dst3 = _mm_loadl_epi64((__m128i*)(dst + 3 * BPS));
159     } else {
160       // Load four bytes/pixels per line.
161       dst0 = _mm_cvtsi32_si128(WebPMemToUint32(dst + 0 * BPS));
162       dst1 = _mm_cvtsi32_si128(WebPMemToUint32(dst + 1 * BPS));
163       dst2 = _mm_cvtsi32_si128(WebPMemToUint32(dst + 2 * BPS));
164       dst3 = _mm_cvtsi32_si128(WebPMemToUint32(dst + 3 * BPS));
165     }
166     // Convert to 16b.
167     dst0 = _mm_unpacklo_epi8(dst0, zero);
168     dst1 = _mm_unpacklo_epi8(dst1, zero);
169     dst2 = _mm_unpacklo_epi8(dst2, zero);
170     dst3 = _mm_unpacklo_epi8(dst3, zero);
171     // Add the inverse transform(s).
172     dst0 = _mm_add_epi16(dst0, T0);
173     dst1 = _mm_add_epi16(dst1, T1);
174     dst2 = _mm_add_epi16(dst2, T2);
175     dst3 = _mm_add_epi16(dst3, T3);
176     // Unsigned saturate to 8b.
177     dst0 = _mm_packus_epi16(dst0, dst0);
178     dst1 = _mm_packus_epi16(dst1, dst1);
179     dst2 = _mm_packus_epi16(dst2, dst2);
180     dst3 = _mm_packus_epi16(dst3, dst3);
181     // Store the results.
182     if (do_two) {
183       // Store eight bytes/pixels per line.
184       _mm_storel_epi64((__m128i*)(dst + 0 * BPS), dst0);
185       _mm_storel_epi64((__m128i*)(dst + 1 * BPS), dst1);
186       _mm_storel_epi64((__m128i*)(dst + 2 * BPS), dst2);
187       _mm_storel_epi64((__m128i*)(dst + 3 * BPS), dst3);
188     } else {
189       // Store four bytes/pixels per line.
190       WebPUint32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(dst0));
191       WebPUint32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(dst1));
192       WebPUint32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(dst2));
193       WebPUint32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(dst3));
194     }
195   }
196 }
197 
198 #if (USE_TRANSFORM_AC3 == 1)
199 #define MUL(a, b) (((a) * (b)) >> 16)
TransformAC3(const int16_t * in,uint8_t * dst)200 static void TransformAC3(const int16_t* in, uint8_t* dst) {
201   static const int kC1 = 20091 + (1 << 16);
202   static const int kC2 = 35468;
203   const __m128i A = _mm_set1_epi16(in[0] + 4);
204   const __m128i c4 = _mm_set1_epi16(MUL(in[4], kC2));
205   const __m128i d4 = _mm_set1_epi16(MUL(in[4], kC1));
206   const int c1 = MUL(in[1], kC2);
207   const int d1 = MUL(in[1], kC1);
208   const __m128i CD = _mm_set_epi16(0, 0, 0, 0, -d1, -c1, c1, d1);
209   const __m128i B = _mm_adds_epi16(A, CD);
210   const __m128i m0 = _mm_adds_epi16(B, d4);
211   const __m128i m1 = _mm_adds_epi16(B, c4);
212   const __m128i m2 = _mm_subs_epi16(B, c4);
213   const __m128i m3 = _mm_subs_epi16(B, d4);
214   const __m128i zero = _mm_setzero_si128();
215   // Load the source pixels.
216   __m128i dst0 = _mm_cvtsi32_si128(WebPMemToUint32(dst + 0 * BPS));
217   __m128i dst1 = _mm_cvtsi32_si128(WebPMemToUint32(dst + 1 * BPS));
218   __m128i dst2 = _mm_cvtsi32_si128(WebPMemToUint32(dst + 2 * BPS));
219   __m128i dst3 = _mm_cvtsi32_si128(WebPMemToUint32(dst + 3 * BPS));
220   // Convert to 16b.
221   dst0 = _mm_unpacklo_epi8(dst0, zero);
222   dst1 = _mm_unpacklo_epi8(dst1, zero);
223   dst2 = _mm_unpacklo_epi8(dst2, zero);
224   dst3 = _mm_unpacklo_epi8(dst3, zero);
225   // Add the inverse transform.
226   dst0 = _mm_adds_epi16(dst0, _mm_srai_epi16(m0, 3));
227   dst1 = _mm_adds_epi16(dst1, _mm_srai_epi16(m1, 3));
228   dst2 = _mm_adds_epi16(dst2, _mm_srai_epi16(m2, 3));
229   dst3 = _mm_adds_epi16(dst3, _mm_srai_epi16(m3, 3));
230   // Unsigned saturate to 8b.
231   dst0 = _mm_packus_epi16(dst0, dst0);
232   dst1 = _mm_packus_epi16(dst1, dst1);
233   dst2 = _mm_packus_epi16(dst2, dst2);
234   dst3 = _mm_packus_epi16(dst3, dst3);
235   // Store the results.
236   WebPUint32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(dst0));
237   WebPUint32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(dst1));
238   WebPUint32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(dst2));
239   WebPUint32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(dst3));
240 }
241 #undef MUL
242 #endif   // USE_TRANSFORM_AC3
243 
244 //------------------------------------------------------------------------------
245 // Loop Filter (Paragraph 15)
246 
247 // Compute abs(p - q) = subs(p - q) OR subs(q - p)
248 #define MM_ABS(p, q)  _mm_or_si128(                                            \
249     _mm_subs_epu8((q), (p)),                                                   \
250     _mm_subs_epu8((p), (q)))
251 
252 // Shift each byte of "x" by 3 bits while preserving by the sign bit.
SignedShift8b_SSE2(__m128i * const x)253 static WEBP_INLINE void SignedShift8b_SSE2(__m128i* const x) {
254   const __m128i zero = _mm_setzero_si128();
255   const __m128i lo_0 = _mm_unpacklo_epi8(zero, *x);
256   const __m128i hi_0 = _mm_unpackhi_epi8(zero, *x);
257   const __m128i lo_1 = _mm_srai_epi16(lo_0, 3 + 8);
258   const __m128i hi_1 = _mm_srai_epi16(hi_0, 3 + 8);
259   *x = _mm_packs_epi16(lo_1, hi_1);
260 }
261 
262 #define FLIP_SIGN_BIT2(a, b) {                                                 \
263   (a) = _mm_xor_si128(a, sign_bit);                                            \
264   (b) = _mm_xor_si128(b, sign_bit);                                            \
265 }
266 
267 #define FLIP_SIGN_BIT4(a, b, c, d) {                                           \
268   FLIP_SIGN_BIT2(a, b);                                                        \
269   FLIP_SIGN_BIT2(c, d);                                                        \
270 }
271 
272 // input/output is uint8_t
GetNotHEV_SSE2(const __m128i * const p1,const __m128i * const p0,const __m128i * const q0,const __m128i * const q1,int hev_thresh,__m128i * const not_hev)273 static WEBP_INLINE void GetNotHEV_SSE2(const __m128i* const p1,
274                                        const __m128i* const p0,
275                                        const __m128i* const q0,
276                                        const __m128i* const q1,
277                                        int hev_thresh, __m128i* const not_hev) {
278   const __m128i zero = _mm_setzero_si128();
279   const __m128i t_1 = MM_ABS(*p1, *p0);
280   const __m128i t_2 = MM_ABS(*q1, *q0);
281 
282   const __m128i h = _mm_set1_epi8(hev_thresh);
283   const __m128i t_max = _mm_max_epu8(t_1, t_2);
284 
285   const __m128i t_max_h = _mm_subs_epu8(t_max, h);
286   *not_hev = _mm_cmpeq_epi8(t_max_h, zero);  // not_hev <= t1 && not_hev <= t2
287 }
288 
289 // input pixels are int8_t
GetBaseDelta_SSE2(const __m128i * const p1,const __m128i * const p0,const __m128i * const q0,const __m128i * const q1,__m128i * const delta)290 static WEBP_INLINE void GetBaseDelta_SSE2(const __m128i* const p1,
291                                           const __m128i* const p0,
292                                           const __m128i* const q0,
293                                           const __m128i* const q1,
294                                           __m128i* const delta) {
295   // beware of addition order, for saturation!
296   const __m128i p1_q1 = _mm_subs_epi8(*p1, *q1);   // p1 - q1
297   const __m128i q0_p0 = _mm_subs_epi8(*q0, *p0);   // q0 - p0
298   const __m128i s1 = _mm_adds_epi8(p1_q1, q0_p0);  // p1 - q1 + 1 * (q0 - p0)
299   const __m128i s2 = _mm_adds_epi8(q0_p0, s1);     // p1 - q1 + 2 * (q0 - p0)
300   const __m128i s3 = _mm_adds_epi8(q0_p0, s2);     // p1 - q1 + 3 * (q0 - p0)
301   *delta = s3;
302 }
303 
304 // input and output are int8_t
DoSimpleFilter_SSE2(__m128i * const p0,__m128i * const q0,const __m128i * const fl)305 static WEBP_INLINE void DoSimpleFilter_SSE2(__m128i* const p0,
306                                             __m128i* const q0,
307                                             const __m128i* const fl) {
308   const __m128i k3 = _mm_set1_epi8(3);
309   const __m128i k4 = _mm_set1_epi8(4);
310   __m128i v3 = _mm_adds_epi8(*fl, k3);
311   __m128i v4 = _mm_adds_epi8(*fl, k4);
312 
313   SignedShift8b_SSE2(&v4);             // v4 >> 3
314   SignedShift8b_SSE2(&v3);             // v3 >> 3
315   *q0 = _mm_subs_epi8(*q0, v4);        // q0 -= v4
316   *p0 = _mm_adds_epi8(*p0, v3);        // p0 += v3
317 }
318 
319 // Updates values of 2 pixels at MB edge during complex filtering.
320 // Update operations:
321 // q = q - delta and p = p + delta; where delta = [(a_hi >> 7), (a_lo >> 7)]
322 // Pixels 'pi' and 'qi' are int8_t on input, uint8_t on output (sign flip).
Update2Pixels_SSE2(__m128i * const pi,__m128i * const qi,const __m128i * const a0_lo,const __m128i * const a0_hi)323 static WEBP_INLINE void Update2Pixels_SSE2(__m128i* const pi, __m128i* const qi,
324                                            const __m128i* const a0_lo,
325                                            const __m128i* const a0_hi) {
326   const __m128i a1_lo = _mm_srai_epi16(*a0_lo, 7);
327   const __m128i a1_hi = _mm_srai_epi16(*a0_hi, 7);
328   const __m128i delta = _mm_packs_epi16(a1_lo, a1_hi);
329   const __m128i sign_bit = _mm_set1_epi8(0x80);
330   *pi = _mm_adds_epi8(*pi, delta);
331   *qi = _mm_subs_epi8(*qi, delta);
332   FLIP_SIGN_BIT2(*pi, *qi);
333 }
334 
335 // input pixels are uint8_t
NeedsFilter_SSE2(const __m128i * const p1,const __m128i * const p0,const __m128i * const q0,const __m128i * const q1,int thresh,__m128i * const mask)336 static WEBP_INLINE void NeedsFilter_SSE2(const __m128i* const p1,
337                                          const __m128i* const p0,
338                                          const __m128i* const q0,
339                                          const __m128i* const q1,
340                                          int thresh, __m128i* const mask) {
341   const __m128i m_thresh = _mm_set1_epi8(thresh);
342   const __m128i t1 = MM_ABS(*p1, *q1);        // abs(p1 - q1)
343   const __m128i kFE = _mm_set1_epi8(0xFE);
344   const __m128i t2 = _mm_and_si128(t1, kFE);  // set lsb of each byte to zero
345   const __m128i t3 = _mm_srli_epi16(t2, 1);   // abs(p1 - q1) / 2
346 
347   const __m128i t4 = MM_ABS(*p0, *q0);        // abs(p0 - q0)
348   const __m128i t5 = _mm_adds_epu8(t4, t4);   // abs(p0 - q0) * 2
349   const __m128i t6 = _mm_adds_epu8(t5, t3);   // abs(p0-q0)*2 + abs(p1-q1)/2
350 
351   const __m128i t7 = _mm_subs_epu8(t6, m_thresh);  // mask <= m_thresh
352   *mask = _mm_cmpeq_epi8(t7, _mm_setzero_si128());
353 }
354 
355 //------------------------------------------------------------------------------
356 // Edge filtering functions
357 
358 // Applies filter on 2 pixels (p0 and q0)
DoFilter2_SSE2(__m128i * const p1,__m128i * const p0,__m128i * const q0,__m128i * const q1,int thresh)359 static WEBP_INLINE void DoFilter2_SSE2(__m128i* const p1, __m128i* const p0,
360                                        __m128i* const q0, __m128i* const q1,
361                                        int thresh) {
362   __m128i a, mask;
363   const __m128i sign_bit = _mm_set1_epi8(0x80);
364   // convert p1/q1 to int8_t (for GetBaseDelta_SSE2)
365   const __m128i p1s = _mm_xor_si128(*p1, sign_bit);
366   const __m128i q1s = _mm_xor_si128(*q1, sign_bit);
367 
368   NeedsFilter_SSE2(p1, p0, q0, q1, thresh, &mask);
369 
370   FLIP_SIGN_BIT2(*p0, *q0);
371   GetBaseDelta_SSE2(&p1s, p0, q0, &q1s, &a);
372   a = _mm_and_si128(a, mask);     // mask filter values we don't care about
373   DoSimpleFilter_SSE2(p0, q0, &a);
374   FLIP_SIGN_BIT2(*p0, *q0);
375 }
376 
377 // Applies filter on 4 pixels (p1, p0, q0 and q1)
DoFilter4_SSE2(__m128i * const p1,__m128i * const p0,__m128i * const q0,__m128i * const q1,const __m128i * const mask,int hev_thresh)378 static WEBP_INLINE void DoFilter4_SSE2(__m128i* const p1, __m128i* const p0,
379                                        __m128i* const q0, __m128i* const q1,
380                                        const __m128i* const mask,
381                                        int hev_thresh) {
382   const __m128i zero = _mm_setzero_si128();
383   const __m128i sign_bit = _mm_set1_epi8(0x80);
384   const __m128i k64 = _mm_set1_epi8(64);
385   const __m128i k3 = _mm_set1_epi8(3);
386   const __m128i k4 = _mm_set1_epi8(4);
387   __m128i not_hev;
388   __m128i t1, t2, t3;
389 
390   // compute hev mask
391   GetNotHEV_SSE2(p1, p0, q0, q1, hev_thresh, &not_hev);
392 
393   // convert to signed values
394   FLIP_SIGN_BIT4(*p1, *p0, *q0, *q1);
395 
396   t1 = _mm_subs_epi8(*p1, *q1);        // p1 - q1
397   t1 = _mm_andnot_si128(not_hev, t1);  // hev(p1 - q1)
398   t2 = _mm_subs_epi8(*q0, *p0);        // q0 - p0
399   t1 = _mm_adds_epi8(t1, t2);          // hev(p1 - q1) + 1 * (q0 - p0)
400   t1 = _mm_adds_epi8(t1, t2);          // hev(p1 - q1) + 2 * (q0 - p0)
401   t1 = _mm_adds_epi8(t1, t2);          // hev(p1 - q1) + 3 * (q0 - p0)
402   t1 = _mm_and_si128(t1, *mask);       // mask filter values we don't care about
403 
404   t2 = _mm_adds_epi8(t1, k3);        // 3 * (q0 - p0) + hev(p1 - q1) + 3
405   t3 = _mm_adds_epi8(t1, k4);        // 3 * (q0 - p0) + hev(p1 - q1) + 4
406   SignedShift8b_SSE2(&t2);           // (3 * (q0 - p0) + hev(p1 - q1) + 3) >> 3
407   SignedShift8b_SSE2(&t3);           // (3 * (q0 - p0) + hev(p1 - q1) + 4) >> 3
408   *p0 = _mm_adds_epi8(*p0, t2);      // p0 += t2
409   *q0 = _mm_subs_epi8(*q0, t3);      // q0 -= t3
410   FLIP_SIGN_BIT2(*p0, *q0);
411 
412   // this is equivalent to signed (a + 1) >> 1 calculation
413   t2 = _mm_add_epi8(t3, sign_bit);
414   t3 = _mm_avg_epu8(t2, zero);
415   t3 = _mm_sub_epi8(t3, k64);
416 
417   t3 = _mm_and_si128(not_hev, t3);   // if !hev
418   *q1 = _mm_subs_epi8(*q1, t3);      // q1 -= t3
419   *p1 = _mm_adds_epi8(*p1, t3);      // p1 += t3
420   FLIP_SIGN_BIT2(*p1, *q1);
421 }
422 
423 // Applies filter on 6 pixels (p2, p1, p0, q0, q1 and q2)
DoFilter6_SSE2(__m128i * const p2,__m128i * const p1,__m128i * const p0,__m128i * const q0,__m128i * const q1,__m128i * const q2,const __m128i * const mask,int hev_thresh)424 static WEBP_INLINE void DoFilter6_SSE2(__m128i* const p2, __m128i* const p1,
425                                        __m128i* const p0, __m128i* const q0,
426                                        __m128i* const q1, __m128i* const q2,
427                                        const __m128i* const mask,
428                                        int hev_thresh) {
429   const __m128i zero = _mm_setzero_si128();
430   const __m128i sign_bit = _mm_set1_epi8(0x80);
431   __m128i a, not_hev;
432 
433   // compute hev mask
434   GetNotHEV_SSE2(p1, p0, q0, q1, hev_thresh, &not_hev);
435 
436   FLIP_SIGN_BIT4(*p1, *p0, *q0, *q1);
437   FLIP_SIGN_BIT2(*p2, *q2);
438   GetBaseDelta_SSE2(p1, p0, q0, q1, &a);
439 
440   { // do simple filter on pixels with hev
441     const __m128i m = _mm_andnot_si128(not_hev, *mask);
442     const __m128i f = _mm_and_si128(a, m);
443     DoSimpleFilter_SSE2(p0, q0, &f);
444   }
445 
446   { // do strong filter on pixels with not hev
447     const __m128i k9 = _mm_set1_epi16(0x0900);
448     const __m128i k63 = _mm_set1_epi16(63);
449 
450     const __m128i m = _mm_and_si128(not_hev, *mask);
451     const __m128i f = _mm_and_si128(a, m);
452 
453     const __m128i f_lo = _mm_unpacklo_epi8(zero, f);
454     const __m128i f_hi = _mm_unpackhi_epi8(zero, f);
455 
456     const __m128i f9_lo = _mm_mulhi_epi16(f_lo, k9);    // Filter (lo) * 9
457     const __m128i f9_hi = _mm_mulhi_epi16(f_hi, k9);    // Filter (hi) * 9
458 
459     const __m128i a2_lo = _mm_add_epi16(f9_lo, k63);    // Filter * 9 + 63
460     const __m128i a2_hi = _mm_add_epi16(f9_hi, k63);    // Filter * 9 + 63
461 
462     const __m128i a1_lo = _mm_add_epi16(a2_lo, f9_lo);  // Filter * 18 + 63
463     const __m128i a1_hi = _mm_add_epi16(a2_hi, f9_hi);  // Filter * 18 + 63
464 
465     const __m128i a0_lo = _mm_add_epi16(a1_lo, f9_lo);  // Filter * 27 + 63
466     const __m128i a0_hi = _mm_add_epi16(a1_hi, f9_hi);  // Filter * 27 + 63
467 
468     Update2Pixels_SSE2(p2, q2, &a2_lo, &a2_hi);
469     Update2Pixels_SSE2(p1, q1, &a1_lo, &a1_hi);
470     Update2Pixels_SSE2(p0, q0, &a0_lo, &a0_hi);
471   }
472 }
473 
474 // reads 8 rows across a vertical edge.
Load8x4_SSE2(const uint8_t * const b,int stride,__m128i * const p,__m128i * const q)475 static WEBP_INLINE void Load8x4_SSE2(const uint8_t* const b, int stride,
476                                      __m128i* const p, __m128i* const q) {
477   // A0 = 63 62 61 60 23 22 21 20 43 42 41 40 03 02 01 00
478   // A1 = 73 72 71 70 33 32 31 30 53 52 51 50 13 12 11 10
479   const __m128i A0 = _mm_set_epi32(
480       WebPMemToUint32(&b[6 * stride]), WebPMemToUint32(&b[2 * stride]),
481       WebPMemToUint32(&b[4 * stride]), WebPMemToUint32(&b[0 * stride]));
482   const __m128i A1 = _mm_set_epi32(
483       WebPMemToUint32(&b[7 * stride]), WebPMemToUint32(&b[3 * stride]),
484       WebPMemToUint32(&b[5 * stride]), WebPMemToUint32(&b[1 * stride]));
485 
486   // B0 = 53 43 52 42 51 41 50 40 13 03 12 02 11 01 10 00
487   // B1 = 73 63 72 62 71 61 70 60 33 23 32 22 31 21 30 20
488   const __m128i B0 = _mm_unpacklo_epi8(A0, A1);
489   const __m128i B1 = _mm_unpackhi_epi8(A0, A1);
490 
491   // C0 = 33 23 13 03 32 22 12 02 31 21 11 01 30 20 10 00
492   // C1 = 73 63 53 43 72 62 52 42 71 61 51 41 70 60 50 40
493   const __m128i C0 = _mm_unpacklo_epi16(B0, B1);
494   const __m128i C1 = _mm_unpackhi_epi16(B0, B1);
495 
496   // *p = 71 61 51 41 31 21 11 01 70 60 50 40 30 20 10 00
497   // *q = 73 63 53 43 33 23 13 03 72 62 52 42 32 22 12 02
498   *p = _mm_unpacklo_epi32(C0, C1);
499   *q = _mm_unpackhi_epi32(C0, C1);
500 }
501 
Load16x4_SSE2(const uint8_t * const r0,const uint8_t * const r8,int stride,__m128i * const p1,__m128i * const p0,__m128i * const q0,__m128i * const q1)502 static WEBP_INLINE void Load16x4_SSE2(const uint8_t* const r0,
503                                       const uint8_t* const r8,
504                                       int stride,
505                                       __m128i* const p1, __m128i* const p0,
506                                       __m128i* const q0, __m128i* const q1) {
507   // Assume the pixels around the edge (|) are numbered as follows
508   //                00 01 | 02 03
509   //                10 11 | 12 13
510   //                 ...  |  ...
511   //                e0 e1 | e2 e3
512   //                f0 f1 | f2 f3
513   //
514   // r0 is pointing to the 0th row (00)
515   // r8 is pointing to the 8th row (80)
516 
517   // Load
518   // p1 = 71 61 51 41 31 21 11 01 70 60 50 40 30 20 10 00
519   // q0 = 73 63 53 43 33 23 13 03 72 62 52 42 32 22 12 02
520   // p0 = f1 e1 d1 c1 b1 a1 91 81 f0 e0 d0 c0 b0 a0 90 80
521   // q1 = f3 e3 d3 c3 b3 a3 93 83 f2 e2 d2 c2 b2 a2 92 82
522   Load8x4_SSE2(r0, stride, p1, q0);
523   Load8x4_SSE2(r8, stride, p0, q1);
524 
525   {
526     // p1 = f0 e0 d0 c0 b0 a0 90 80 70 60 50 40 30 20 10 00
527     // p0 = f1 e1 d1 c1 b1 a1 91 81 71 61 51 41 31 21 11 01
528     // q0 = f2 e2 d2 c2 b2 a2 92 82 72 62 52 42 32 22 12 02
529     // q1 = f3 e3 d3 c3 b3 a3 93 83 73 63 53 43 33 23 13 03
530     const __m128i t1 = *p1;
531     const __m128i t2 = *q0;
532     *p1 = _mm_unpacklo_epi64(t1, *p0);
533     *p0 = _mm_unpackhi_epi64(t1, *p0);
534     *q0 = _mm_unpacklo_epi64(t2, *q1);
535     *q1 = _mm_unpackhi_epi64(t2, *q1);
536   }
537 }
538 
Store4x4_SSE2(__m128i * const x,uint8_t * dst,int stride)539 static WEBP_INLINE void Store4x4_SSE2(__m128i* const x,
540                                       uint8_t* dst, int stride) {
541   int i;
542   for (i = 0; i < 4; ++i, dst += stride) {
543     WebPUint32ToMem(dst, _mm_cvtsi128_si32(*x));
544     *x = _mm_srli_si128(*x, 4);
545   }
546 }
547 
548 // Transpose back and store
Store16x4_SSE2(const __m128i * const p1,const __m128i * const p0,const __m128i * const q0,const __m128i * const q1,uint8_t * r0,uint8_t * r8,int stride)549 static WEBP_INLINE void Store16x4_SSE2(const __m128i* const p1,
550                                        const __m128i* const p0,
551                                        const __m128i* const q0,
552                                        const __m128i* const q1,
553                                        uint8_t* r0, uint8_t* r8,
554                                        int stride) {
555   __m128i t1, p1_s, p0_s, q0_s, q1_s;
556 
557   // p0 = 71 70 61 60 51 50 41 40 31 30 21 20 11 10 01 00
558   // p1 = f1 f0 e1 e0 d1 d0 c1 c0 b1 b0 a1 a0 91 90 81 80
559   t1 = *p0;
560   p0_s = _mm_unpacklo_epi8(*p1, t1);
561   p1_s = _mm_unpackhi_epi8(*p1, t1);
562 
563   // q0 = 73 72 63 62 53 52 43 42 33 32 23 22 13 12 03 02
564   // q1 = f3 f2 e3 e2 d3 d2 c3 c2 b3 b2 a3 a2 93 92 83 82
565   t1 = *q0;
566   q0_s = _mm_unpacklo_epi8(t1, *q1);
567   q1_s = _mm_unpackhi_epi8(t1, *q1);
568 
569   // p0 = 33 32 31 30 23 22 21 20 13 12 11 10 03 02 01 00
570   // q0 = 73 72 71 70 63 62 61 60 53 52 51 50 43 42 41 40
571   t1 = p0_s;
572   p0_s = _mm_unpacklo_epi16(t1, q0_s);
573   q0_s = _mm_unpackhi_epi16(t1, q0_s);
574 
575   // p1 = b3 b2 b1 b0 a3 a2 a1 a0 93 92 91 90 83 82 81 80
576   // q1 = f3 f2 f1 f0 e3 e2 e1 e0 d3 d2 d1 d0 c3 c2 c1 c0
577   t1 = p1_s;
578   p1_s = _mm_unpacklo_epi16(t1, q1_s);
579   q1_s = _mm_unpackhi_epi16(t1, q1_s);
580 
581   Store4x4_SSE2(&p0_s, r0, stride);
582   r0 += 4 * stride;
583   Store4x4_SSE2(&q0_s, r0, stride);
584 
585   Store4x4_SSE2(&p1_s, r8, stride);
586   r8 += 4 * stride;
587   Store4x4_SSE2(&q1_s, r8, stride);
588 }
589 
590 //------------------------------------------------------------------------------
591 // Simple In-loop filtering (Paragraph 15.2)
592 
SimpleVFilter16_SSE2(uint8_t * p,int stride,int thresh)593 static void SimpleVFilter16_SSE2(uint8_t* p, int stride, int thresh) {
594   // Load
595   __m128i p1 = _mm_loadu_si128((__m128i*)&p[-2 * stride]);
596   __m128i p0 = _mm_loadu_si128((__m128i*)&p[-stride]);
597   __m128i q0 = _mm_loadu_si128((__m128i*)&p[0]);
598   __m128i q1 = _mm_loadu_si128((__m128i*)&p[stride]);
599 
600   DoFilter2_SSE2(&p1, &p0, &q0, &q1, thresh);
601 
602   // Store
603   _mm_storeu_si128((__m128i*)&p[-stride], p0);
604   _mm_storeu_si128((__m128i*)&p[0], q0);
605 }
606 
SimpleHFilter16_SSE2(uint8_t * p,int stride,int thresh)607 static void SimpleHFilter16_SSE2(uint8_t* p, int stride, int thresh) {
608   __m128i p1, p0, q0, q1;
609 
610   p -= 2;  // beginning of p1
611 
612   Load16x4_SSE2(p, p + 8 * stride, stride, &p1, &p0, &q0, &q1);
613   DoFilter2_SSE2(&p1, &p0, &q0, &q1, thresh);
614   Store16x4_SSE2(&p1, &p0, &q0, &q1, p, p + 8 * stride, stride);
615 }
616 
SimpleVFilter16i_SSE2(uint8_t * p,int stride,int thresh)617 static void SimpleVFilter16i_SSE2(uint8_t* p, int stride, int thresh) {
618   int k;
619   for (k = 3; k > 0; --k) {
620     p += 4 * stride;
621     SimpleVFilter16_SSE2(p, stride, thresh);
622   }
623 }
624 
SimpleHFilter16i_SSE2(uint8_t * p,int stride,int thresh)625 static void SimpleHFilter16i_SSE2(uint8_t* p, int stride, int thresh) {
626   int k;
627   for (k = 3; k > 0; --k) {
628     p += 4;
629     SimpleHFilter16_SSE2(p, stride, thresh);
630   }
631 }
632 
633 //------------------------------------------------------------------------------
634 // Complex In-loop filtering (Paragraph 15.3)
635 
636 #define MAX_DIFF1(p3, p2, p1, p0, m) do {                                      \
637   (m) = MM_ABS(p1, p0);                                                        \
638   (m) = _mm_max_epu8(m, MM_ABS(p3, p2));                                       \
639   (m) = _mm_max_epu8(m, MM_ABS(p2, p1));                                       \
640 } while (0)
641 
642 #define MAX_DIFF2(p3, p2, p1, p0, m) do {                                      \
643   (m) = _mm_max_epu8(m, MM_ABS(p1, p0));                                       \
644   (m) = _mm_max_epu8(m, MM_ABS(p3, p2));                                       \
645   (m) = _mm_max_epu8(m, MM_ABS(p2, p1));                                       \
646 } while (0)
647 
648 #define LOAD_H_EDGES4(p, stride, e1, e2, e3, e4) {                             \
649   (e1) = _mm_loadu_si128((__m128i*)&(p)[0 * (stride)]);                        \
650   (e2) = _mm_loadu_si128((__m128i*)&(p)[1 * (stride)]);                        \
651   (e3) = _mm_loadu_si128((__m128i*)&(p)[2 * (stride)]);                        \
652   (e4) = _mm_loadu_si128((__m128i*)&(p)[3 * (stride)]);                        \
653 }
654 
655 #define LOADUV_H_EDGE(p, u, v, stride) do {                                    \
656   const __m128i U = _mm_loadl_epi64((__m128i*)&(u)[(stride)]);                 \
657   const __m128i V = _mm_loadl_epi64((__m128i*)&(v)[(stride)]);                 \
658   (p) = _mm_unpacklo_epi64(U, V);                                              \
659 } while (0)
660 
661 #define LOADUV_H_EDGES4(u, v, stride, e1, e2, e3, e4) {                        \
662   LOADUV_H_EDGE(e1, u, v, 0 * (stride));                                       \
663   LOADUV_H_EDGE(e2, u, v, 1 * (stride));                                       \
664   LOADUV_H_EDGE(e3, u, v, 2 * (stride));                                       \
665   LOADUV_H_EDGE(e4, u, v, 3 * (stride));                                       \
666 }
667 
668 #define STOREUV(p, u, v, stride) {                                             \
669   _mm_storel_epi64((__m128i*)&(u)[(stride)], p);                               \
670   (p) = _mm_srli_si128(p, 8);                                                  \
671   _mm_storel_epi64((__m128i*)&(v)[(stride)], p);                               \
672 }
673 
ComplexMask_SSE2(const __m128i * const p1,const __m128i * const p0,const __m128i * const q0,const __m128i * const q1,int thresh,int ithresh,__m128i * const mask)674 static WEBP_INLINE void ComplexMask_SSE2(const __m128i* const p1,
675                                          const __m128i* const p0,
676                                          const __m128i* const q0,
677                                          const __m128i* const q1,
678                                          int thresh, int ithresh,
679                                          __m128i* const mask) {
680   const __m128i it = _mm_set1_epi8(ithresh);
681   const __m128i diff = _mm_subs_epu8(*mask, it);
682   const __m128i thresh_mask = _mm_cmpeq_epi8(diff, _mm_setzero_si128());
683   __m128i filter_mask;
684   NeedsFilter_SSE2(p1, p0, q0, q1, thresh, &filter_mask);
685   *mask = _mm_and_si128(thresh_mask, filter_mask);
686 }
687 
688 // on macroblock edges
VFilter16_SSE2(uint8_t * p,int stride,int thresh,int ithresh,int hev_thresh)689 static void VFilter16_SSE2(uint8_t* p, int stride,
690                            int thresh, int ithresh, int hev_thresh) {
691   __m128i t1;
692   __m128i mask;
693   __m128i p2, p1, p0, q0, q1, q2;
694 
695   // Load p3, p2, p1, p0
696   LOAD_H_EDGES4(p - 4 * stride, stride, t1, p2, p1, p0);
697   MAX_DIFF1(t1, p2, p1, p0, mask);
698 
699   // Load q0, q1, q2, q3
700   LOAD_H_EDGES4(p, stride, q0, q1, q2, t1);
701   MAX_DIFF2(t1, q2, q1, q0, mask);
702 
703   ComplexMask_SSE2(&p1, &p0, &q0, &q1, thresh, ithresh, &mask);
704   DoFilter6_SSE2(&p2, &p1, &p0, &q0, &q1, &q2, &mask, hev_thresh);
705 
706   // Store
707   _mm_storeu_si128((__m128i*)&p[-3 * stride], p2);
708   _mm_storeu_si128((__m128i*)&p[-2 * stride], p1);
709   _mm_storeu_si128((__m128i*)&p[-1 * stride], p0);
710   _mm_storeu_si128((__m128i*)&p[+0 * stride], q0);
711   _mm_storeu_si128((__m128i*)&p[+1 * stride], q1);
712   _mm_storeu_si128((__m128i*)&p[+2 * stride], q2);
713 }
714 
HFilter16_SSE2(uint8_t * p,int stride,int thresh,int ithresh,int hev_thresh)715 static void HFilter16_SSE2(uint8_t* p, int stride,
716                            int thresh, int ithresh, int hev_thresh) {
717   __m128i mask;
718   __m128i p3, p2, p1, p0, q0, q1, q2, q3;
719 
720   uint8_t* const b = p - 4;
721   Load16x4_SSE2(b, b + 8 * stride, stride, &p3, &p2, &p1, &p0);
722   MAX_DIFF1(p3, p2, p1, p0, mask);
723 
724   Load16x4_SSE2(p, p + 8 * stride, stride, &q0, &q1, &q2, &q3);
725   MAX_DIFF2(q3, q2, q1, q0, mask);
726 
727   ComplexMask_SSE2(&p1, &p0, &q0, &q1, thresh, ithresh, &mask);
728   DoFilter6_SSE2(&p2, &p1, &p0, &q0, &q1, &q2, &mask, hev_thresh);
729 
730   Store16x4_SSE2(&p3, &p2, &p1, &p0, b, b + 8 * stride, stride);
731   Store16x4_SSE2(&q0, &q1, &q2, &q3, p, p + 8 * stride, stride);
732 }
733 
734 // on three inner edges
VFilter16i_SSE2(uint8_t * p,int stride,int thresh,int ithresh,int hev_thresh)735 static void VFilter16i_SSE2(uint8_t* p, int stride,
736                             int thresh, int ithresh, int hev_thresh) {
737   int k;
738   __m128i p3, p2, p1, p0;   // loop invariants
739 
740   LOAD_H_EDGES4(p, stride, p3, p2, p1, p0);  // prologue
741 
742   for (k = 3; k > 0; --k) {
743     __m128i mask, tmp1, tmp2;
744     uint8_t* const b = p + 2 * stride;   // beginning of p1
745     p += 4 * stride;
746 
747     MAX_DIFF1(p3, p2, p1, p0, mask);   // compute partial mask
748     LOAD_H_EDGES4(p, stride, p3, p2, tmp1, tmp2);
749     MAX_DIFF2(p3, p2, tmp1, tmp2, mask);
750 
751     // p3 and p2 are not just temporary variables here: they will be
752     // re-used for next span. And q2/q3 will become p1/p0 accordingly.
753     ComplexMask_SSE2(&p1, &p0, &p3, &p2, thresh, ithresh, &mask);
754     DoFilter4_SSE2(&p1, &p0, &p3, &p2, &mask, hev_thresh);
755 
756     // Store
757     _mm_storeu_si128((__m128i*)&b[0 * stride], p1);
758     _mm_storeu_si128((__m128i*)&b[1 * stride], p0);
759     _mm_storeu_si128((__m128i*)&b[2 * stride], p3);
760     _mm_storeu_si128((__m128i*)&b[3 * stride], p2);
761 
762     // rotate samples
763     p1 = tmp1;
764     p0 = tmp2;
765   }
766 }
767 
HFilter16i_SSE2(uint8_t * p,int stride,int thresh,int ithresh,int hev_thresh)768 static void HFilter16i_SSE2(uint8_t* p, int stride,
769                             int thresh, int ithresh, int hev_thresh) {
770   int k;
771   __m128i p3, p2, p1, p0;   // loop invariants
772 
773   Load16x4_SSE2(p, p + 8 * stride, stride, &p3, &p2, &p1, &p0);  // prologue
774 
775   for (k = 3; k > 0; --k) {
776     __m128i mask, tmp1, tmp2;
777     uint8_t* const b = p + 2;   // beginning of p1
778 
779     p += 4;  // beginning of q0 (and next span)
780 
781     MAX_DIFF1(p3, p2, p1, p0, mask);   // compute partial mask
782     Load16x4_SSE2(p, p + 8 * stride, stride, &p3, &p2, &tmp1, &tmp2);
783     MAX_DIFF2(p3, p2, tmp1, tmp2, mask);
784 
785     ComplexMask_SSE2(&p1, &p0, &p3, &p2, thresh, ithresh, &mask);
786     DoFilter4_SSE2(&p1, &p0, &p3, &p2, &mask, hev_thresh);
787 
788     Store16x4_SSE2(&p1, &p0, &p3, &p2, b, b + 8 * stride, stride);
789 
790     // rotate samples
791     p1 = tmp1;
792     p0 = tmp2;
793   }
794 }
795 
796 // 8-pixels wide variant, for chroma filtering
VFilter8_SSE2(uint8_t * u,uint8_t * v,int stride,int thresh,int ithresh,int hev_thresh)797 static void VFilter8_SSE2(uint8_t* u, uint8_t* v, int stride,
798                           int thresh, int ithresh, int hev_thresh) {
799   __m128i mask;
800   __m128i t1, p2, p1, p0, q0, q1, q2;
801 
802   // Load p3, p2, p1, p0
803   LOADUV_H_EDGES4(u - 4 * stride, v - 4 * stride, stride, t1, p2, p1, p0);
804   MAX_DIFF1(t1, p2, p1, p0, mask);
805 
806   // Load q0, q1, q2, q3
807   LOADUV_H_EDGES4(u, v, stride, q0, q1, q2, t1);
808   MAX_DIFF2(t1, q2, q1, q0, mask);
809 
810   ComplexMask_SSE2(&p1, &p0, &q0, &q1, thresh, ithresh, &mask);
811   DoFilter6_SSE2(&p2, &p1, &p0, &q0, &q1, &q2, &mask, hev_thresh);
812 
813   // Store
814   STOREUV(p2, u, v, -3 * stride);
815   STOREUV(p1, u, v, -2 * stride);
816   STOREUV(p0, u, v, -1 * stride);
817   STOREUV(q0, u, v, 0 * stride);
818   STOREUV(q1, u, v, 1 * stride);
819   STOREUV(q2, u, v, 2 * stride);
820 }
821 
HFilter8_SSE2(uint8_t * u,uint8_t * v,int stride,int thresh,int ithresh,int hev_thresh)822 static void HFilter8_SSE2(uint8_t* u, uint8_t* v, int stride,
823                           int thresh, int ithresh, int hev_thresh) {
824   __m128i mask;
825   __m128i p3, p2, p1, p0, q0, q1, q2, q3;
826 
827   uint8_t* const tu = u - 4;
828   uint8_t* const tv = v - 4;
829   Load16x4_SSE2(tu, tv, stride, &p3, &p2, &p1, &p0);
830   MAX_DIFF1(p3, p2, p1, p0, mask);
831 
832   Load16x4_SSE2(u, v, stride, &q0, &q1, &q2, &q3);
833   MAX_DIFF2(q3, q2, q1, q0, mask);
834 
835   ComplexMask_SSE2(&p1, &p0, &q0, &q1, thresh, ithresh, &mask);
836   DoFilter6_SSE2(&p2, &p1, &p0, &q0, &q1, &q2, &mask, hev_thresh);
837 
838   Store16x4_SSE2(&p3, &p2, &p1, &p0, tu, tv, stride);
839   Store16x4_SSE2(&q0, &q1, &q2, &q3, u, v, stride);
840 }
841 
VFilter8i_SSE2(uint8_t * u,uint8_t * v,int stride,int thresh,int ithresh,int hev_thresh)842 static void VFilter8i_SSE2(uint8_t* u, uint8_t* v, int stride,
843                            int thresh, int ithresh, int hev_thresh) {
844   __m128i mask;
845   __m128i t1, t2, p1, p0, q0, q1;
846 
847   // Load p3, p2, p1, p0
848   LOADUV_H_EDGES4(u, v, stride, t2, t1, p1, p0);
849   MAX_DIFF1(t2, t1, p1, p0, mask);
850 
851   u += 4 * stride;
852   v += 4 * stride;
853 
854   // Load q0, q1, q2, q3
855   LOADUV_H_EDGES4(u, v, stride, q0, q1, t1, t2);
856   MAX_DIFF2(t2, t1, q1, q0, mask);
857 
858   ComplexMask_SSE2(&p1, &p0, &q0, &q1, thresh, ithresh, &mask);
859   DoFilter4_SSE2(&p1, &p0, &q0, &q1, &mask, hev_thresh);
860 
861   // Store
862   STOREUV(p1, u, v, -2 * stride);
863   STOREUV(p0, u, v, -1 * stride);
864   STOREUV(q0, u, v, 0 * stride);
865   STOREUV(q1, u, v, 1 * stride);
866 }
867 
HFilter8i_SSE2(uint8_t * u,uint8_t * v,int stride,int thresh,int ithresh,int hev_thresh)868 static void HFilter8i_SSE2(uint8_t* u, uint8_t* v, int stride,
869                            int thresh, int ithresh, int hev_thresh) {
870   __m128i mask;
871   __m128i t1, t2, p1, p0, q0, q1;
872   Load16x4_SSE2(u, v, stride, &t2, &t1, &p1, &p0);   // p3, p2, p1, p0
873   MAX_DIFF1(t2, t1, p1, p0, mask);
874 
875   u += 4;  // beginning of q0
876   v += 4;
877   Load16x4_SSE2(u, v, stride, &q0, &q1, &t1, &t2);  // q0, q1, q2, q3
878   MAX_DIFF2(t2, t1, q1, q0, mask);
879 
880   ComplexMask_SSE2(&p1, &p0, &q0, &q1, thresh, ithresh, &mask);
881   DoFilter4_SSE2(&p1, &p0, &q0, &q1, &mask, hev_thresh);
882 
883   u -= 2;  // beginning of p1
884   v -= 2;
885   Store16x4_SSE2(&p1, &p0, &q0, &q1, u, v, stride);
886 }
887 
888 //------------------------------------------------------------------------------
889 // 4x4 predictions
890 
891 #define DST(x, y) dst[(x) + (y) * BPS]
892 #define AVG3(a, b, c) (((a) + 2 * (b) + (c) + 2) >> 2)
893 
894 // We use the following 8b-arithmetic tricks:
895 //     (a + 2 * b + c + 2) >> 2 = (AC + b + 1) >> 1
896 //   where: AC = (a + c) >> 1 = [(a + c + 1) >> 1] - [(a^c) & 1]
897 // and:
898 //     (a + 2 * b + c + 2) >> 2 = (AB + BC + 1) >> 1 - (ab|bc)&lsb
899 //   where: AC = (a + b + 1) >> 1,   BC = (b + c + 1) >> 1
900 //   and ab = a ^ b, bc = b ^ c, lsb = (AC^BC)&1
901 
VE4_SSE2(uint8_t * dst)902 static void VE4_SSE2(uint8_t* dst) {    // vertical
903   const __m128i one = _mm_set1_epi8(1);
904   const __m128i ABCDEFGH = _mm_loadl_epi64((__m128i*)(dst - BPS - 1));
905   const __m128i BCDEFGH0 = _mm_srli_si128(ABCDEFGH, 1);
906   const __m128i CDEFGH00 = _mm_srli_si128(ABCDEFGH, 2);
907   const __m128i a = _mm_avg_epu8(ABCDEFGH, CDEFGH00);
908   const __m128i lsb = _mm_and_si128(_mm_xor_si128(ABCDEFGH, CDEFGH00), one);
909   const __m128i b = _mm_subs_epu8(a, lsb);
910   const __m128i avg = _mm_avg_epu8(b, BCDEFGH0);
911   const uint32_t vals = _mm_cvtsi128_si32(avg);
912   int i;
913   for (i = 0; i < 4; ++i) {
914     WebPUint32ToMem(dst + i * BPS, vals);
915   }
916 }
917 
LD4_SSE2(uint8_t * dst)918 static void LD4_SSE2(uint8_t* dst) {   // Down-Left
919   const __m128i one = _mm_set1_epi8(1);
920   const __m128i ABCDEFGH = _mm_loadl_epi64((__m128i*)(dst - BPS));
921   const __m128i BCDEFGH0 = _mm_srli_si128(ABCDEFGH, 1);
922   const __m128i CDEFGH00 = _mm_srli_si128(ABCDEFGH, 2);
923   const __m128i CDEFGHH0 = _mm_insert_epi16(CDEFGH00, dst[-BPS + 7], 3);
924   const __m128i avg1 = _mm_avg_epu8(ABCDEFGH, CDEFGHH0);
925   const __m128i lsb = _mm_and_si128(_mm_xor_si128(ABCDEFGH, CDEFGHH0), one);
926   const __m128i avg2 = _mm_subs_epu8(avg1, lsb);
927   const __m128i abcdefg = _mm_avg_epu8(avg2, BCDEFGH0);
928   WebPUint32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(               abcdefg    ));
929   WebPUint32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 1)));
930   WebPUint32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 2)));
931   WebPUint32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 3)));
932 }
933 
VR4_SSE2(uint8_t * dst)934 static void VR4_SSE2(uint8_t* dst) {   // Vertical-Right
935   const __m128i one = _mm_set1_epi8(1);
936   const int I = dst[-1 + 0 * BPS];
937   const int J = dst[-1 + 1 * BPS];
938   const int K = dst[-1 + 2 * BPS];
939   const int X = dst[-1 - BPS];
940   const __m128i XABCD = _mm_loadl_epi64((__m128i*)(dst - BPS - 1));
941   const __m128i ABCD0 = _mm_srli_si128(XABCD, 1);
942   const __m128i abcd = _mm_avg_epu8(XABCD, ABCD0);
943   const __m128i _XABCD = _mm_slli_si128(XABCD, 1);
944   const __m128i IXABCD = _mm_insert_epi16(_XABCD, I | (X << 8), 0);
945   const __m128i avg1 = _mm_avg_epu8(IXABCD, ABCD0);
946   const __m128i lsb = _mm_and_si128(_mm_xor_si128(IXABCD, ABCD0), one);
947   const __m128i avg2 = _mm_subs_epu8(avg1, lsb);
948   const __m128i efgh = _mm_avg_epu8(avg2, XABCD);
949   WebPUint32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(               abcd    ));
950   WebPUint32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(               efgh    ));
951   WebPUint32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(_mm_slli_si128(abcd, 1)));
952   WebPUint32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(_mm_slli_si128(efgh, 1)));
953 
954   // these two are hard to implement in SSE2, so we keep the C-version:
955   DST(0, 2) = AVG3(J, I, X);
956   DST(0, 3) = AVG3(K, J, I);
957 }
958 
VL4_SSE2(uint8_t * dst)959 static void VL4_SSE2(uint8_t* dst) {   // Vertical-Left
960   const __m128i one = _mm_set1_epi8(1);
961   const __m128i ABCDEFGH = _mm_loadl_epi64((__m128i*)(dst - BPS));
962   const __m128i BCDEFGH_ = _mm_srli_si128(ABCDEFGH, 1);
963   const __m128i CDEFGH__ = _mm_srli_si128(ABCDEFGH, 2);
964   const __m128i avg1 = _mm_avg_epu8(ABCDEFGH, BCDEFGH_);
965   const __m128i avg2 = _mm_avg_epu8(CDEFGH__, BCDEFGH_);
966   const __m128i avg3 = _mm_avg_epu8(avg1, avg2);
967   const __m128i lsb1 = _mm_and_si128(_mm_xor_si128(avg1, avg2), one);
968   const __m128i ab = _mm_xor_si128(ABCDEFGH, BCDEFGH_);
969   const __m128i bc = _mm_xor_si128(CDEFGH__, BCDEFGH_);
970   const __m128i abbc = _mm_or_si128(ab, bc);
971   const __m128i lsb2 = _mm_and_si128(abbc, lsb1);
972   const __m128i avg4 = _mm_subs_epu8(avg3, lsb2);
973   const uint32_t extra_out = _mm_cvtsi128_si32(_mm_srli_si128(avg4, 4));
974   WebPUint32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(               avg1    ));
975   WebPUint32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(               avg4    ));
976   WebPUint32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(avg1, 1)));
977   WebPUint32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(avg4, 1)));
978 
979   // these two are hard to get and irregular
980   DST(3, 2) = (extra_out >> 0) & 0xff;
981   DST(3, 3) = (extra_out >> 8) & 0xff;
982 }
983 
RD4_SSE2(uint8_t * dst)984 static void RD4_SSE2(uint8_t* dst) {   // Down-right
985   const __m128i one = _mm_set1_epi8(1);
986   const __m128i XABCD = _mm_loadl_epi64((__m128i*)(dst - BPS - 1));
987   const __m128i ____XABCD = _mm_slli_si128(XABCD, 4);
988   const uint32_t I = dst[-1 + 0 * BPS];
989   const uint32_t J = dst[-1 + 1 * BPS];
990   const uint32_t K = dst[-1 + 2 * BPS];
991   const uint32_t L = dst[-1 + 3 * BPS];
992   const __m128i LKJI_____ =
993       _mm_cvtsi32_si128(L | (K << 8) | (J << 16) | (I << 24));
994   const __m128i LKJIXABCD = _mm_or_si128(LKJI_____, ____XABCD);
995   const __m128i KJIXABCD_ = _mm_srli_si128(LKJIXABCD, 1);
996   const __m128i JIXABCD__ = _mm_srli_si128(LKJIXABCD, 2);
997   const __m128i avg1 = _mm_avg_epu8(JIXABCD__, LKJIXABCD);
998   const __m128i lsb = _mm_and_si128(_mm_xor_si128(JIXABCD__, LKJIXABCD), one);
999   const __m128i avg2 = _mm_subs_epu8(avg1, lsb);
1000   const __m128i abcdefg = _mm_avg_epu8(avg2, KJIXABCD_);
1001   WebPUint32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(               abcdefg    ));
1002   WebPUint32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 1)));
1003   WebPUint32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 2)));
1004   WebPUint32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 3)));
1005 }
1006 
1007 #undef DST
1008 #undef AVG3
1009 
1010 //------------------------------------------------------------------------------
1011 // Luma 16x16
1012 
TrueMotion_SSE2(uint8_t * dst,int size)1013 static WEBP_INLINE void TrueMotion_SSE2(uint8_t* dst, int size) {
1014   const uint8_t* top = dst - BPS;
1015   const __m128i zero = _mm_setzero_si128();
1016   int y;
1017   if (size == 4) {
1018     const __m128i top_values = _mm_cvtsi32_si128(WebPMemToUint32(top));
1019     const __m128i top_base = _mm_unpacklo_epi8(top_values, zero);
1020     for (y = 0; y < 4; ++y, dst += BPS) {
1021       const int val = dst[-1] - top[-1];
1022       const __m128i base = _mm_set1_epi16(val);
1023       const __m128i out = _mm_packus_epi16(_mm_add_epi16(base, top_base), zero);
1024       WebPUint32ToMem(dst, _mm_cvtsi128_si32(out));
1025     }
1026   } else if (size == 8) {
1027     const __m128i top_values = _mm_loadl_epi64((const __m128i*)top);
1028     const __m128i top_base = _mm_unpacklo_epi8(top_values, zero);
1029     for (y = 0; y < 8; ++y, dst += BPS) {
1030       const int val = dst[-1] - top[-1];
1031       const __m128i base = _mm_set1_epi16(val);
1032       const __m128i out = _mm_packus_epi16(_mm_add_epi16(base, top_base), zero);
1033       _mm_storel_epi64((__m128i*)dst, out);
1034     }
1035   } else {
1036     const __m128i top_values = _mm_loadu_si128((const __m128i*)top);
1037     const __m128i top_base_0 = _mm_unpacklo_epi8(top_values, zero);
1038     const __m128i top_base_1 = _mm_unpackhi_epi8(top_values, zero);
1039     for (y = 0; y < 16; ++y, dst += BPS) {
1040       const int val = dst[-1] - top[-1];
1041       const __m128i base = _mm_set1_epi16(val);
1042       const __m128i out_0 = _mm_add_epi16(base, top_base_0);
1043       const __m128i out_1 = _mm_add_epi16(base, top_base_1);
1044       const __m128i out = _mm_packus_epi16(out_0, out_1);
1045       _mm_storeu_si128((__m128i*)dst, out);
1046     }
1047   }
1048 }
1049 
TM4_SSE2(uint8_t * dst)1050 static void TM4_SSE2(uint8_t* dst)   { TrueMotion_SSE2(dst, 4); }
TM8uv_SSE2(uint8_t * dst)1051 static void TM8uv_SSE2(uint8_t* dst) { TrueMotion_SSE2(dst, 8); }
TM16_SSE2(uint8_t * dst)1052 static void TM16_SSE2(uint8_t* dst)  { TrueMotion_SSE2(dst, 16); }
1053 
VE16_SSE2(uint8_t * dst)1054 static void VE16_SSE2(uint8_t* dst) {
1055   const __m128i top = _mm_loadu_si128((const __m128i*)(dst - BPS));
1056   int j;
1057   for (j = 0; j < 16; ++j) {
1058     _mm_storeu_si128((__m128i*)(dst + j * BPS), top);
1059   }
1060 }
1061 
HE16_SSE2(uint8_t * dst)1062 static void HE16_SSE2(uint8_t* dst) {     // horizontal
1063   int j;
1064   for (j = 16; j > 0; --j) {
1065     const __m128i values = _mm_set1_epi8(dst[-1]);
1066     _mm_storeu_si128((__m128i*)dst, values);
1067     dst += BPS;
1068   }
1069 }
1070 
Put16_SSE2(uint8_t v,uint8_t * dst)1071 static WEBP_INLINE void Put16_SSE2(uint8_t v, uint8_t* dst) {
1072   int j;
1073   const __m128i values = _mm_set1_epi8(v);
1074   for (j = 0; j < 16; ++j) {
1075     _mm_storeu_si128((__m128i*)(dst + j * BPS), values);
1076   }
1077 }
1078 
DC16_SSE2(uint8_t * dst)1079 static void DC16_SSE2(uint8_t* dst) {  // DC
1080   const __m128i zero = _mm_setzero_si128();
1081   const __m128i top = _mm_loadu_si128((const __m128i*)(dst - BPS));
1082   const __m128i sad8x2 = _mm_sad_epu8(top, zero);
1083   // sum the two sads: sad8x2[0:1] + sad8x2[8:9]
1084   const __m128i sum = _mm_add_epi16(sad8x2, _mm_shuffle_epi32(sad8x2, 2));
1085   int left = 0;
1086   int j;
1087   for (j = 0; j < 16; ++j) {
1088     left += dst[-1 + j * BPS];
1089   }
1090   {
1091     const int DC = _mm_cvtsi128_si32(sum) + left + 16;
1092     Put16_SSE2(DC >> 5, dst);
1093   }
1094 }
1095 
DC16NoTop_SSE2(uint8_t * dst)1096 static void DC16NoTop_SSE2(uint8_t* dst) {  // DC with top samples unavailable
1097   int DC = 8;
1098   int j;
1099   for (j = 0; j < 16; ++j) {
1100     DC += dst[-1 + j * BPS];
1101   }
1102   Put16_SSE2(DC >> 4, dst);
1103 }
1104 
DC16NoLeft_SSE2(uint8_t * dst)1105 static void DC16NoLeft_SSE2(uint8_t* dst) {  // DC with left samples unavailable
1106   const __m128i zero = _mm_setzero_si128();
1107   const __m128i top = _mm_loadu_si128((const __m128i*)(dst - BPS));
1108   const __m128i sad8x2 = _mm_sad_epu8(top, zero);
1109   // sum the two sads: sad8x2[0:1] + sad8x2[8:9]
1110   const __m128i sum = _mm_add_epi16(sad8x2, _mm_shuffle_epi32(sad8x2, 2));
1111   const int DC = _mm_cvtsi128_si32(sum) + 8;
1112   Put16_SSE2(DC >> 4, dst);
1113 }
1114 
DC16NoTopLeft_SSE2(uint8_t * dst)1115 static void DC16NoTopLeft_SSE2(uint8_t* dst) {  // DC with no top & left samples
1116   Put16_SSE2(0x80, dst);
1117 }
1118 
1119 //------------------------------------------------------------------------------
1120 // Chroma
1121 
VE8uv_SSE2(uint8_t * dst)1122 static void VE8uv_SSE2(uint8_t* dst) {    // vertical
1123   int j;
1124   const __m128i top = _mm_loadl_epi64((const __m128i*)(dst - BPS));
1125   for (j = 0; j < 8; ++j) {
1126     _mm_storel_epi64((__m128i*)(dst + j * BPS), top);
1127   }
1128 }
1129 
1130 // helper for chroma-DC predictions
Put8x8uv_SSE2(uint8_t v,uint8_t * dst)1131 static WEBP_INLINE void Put8x8uv_SSE2(uint8_t v, uint8_t* dst) {
1132   int j;
1133   const __m128i values = _mm_set1_epi8(v);
1134   for (j = 0; j < 8; ++j) {
1135     _mm_storel_epi64((__m128i*)(dst + j * BPS), values);
1136   }
1137 }
1138 
DC8uv_SSE2(uint8_t * dst)1139 static void DC8uv_SSE2(uint8_t* dst) {     // DC
1140   const __m128i zero = _mm_setzero_si128();
1141   const __m128i top = _mm_loadl_epi64((const __m128i*)(dst - BPS));
1142   const __m128i sum = _mm_sad_epu8(top, zero);
1143   int left = 0;
1144   int j;
1145   for (j = 0; j < 8; ++j) {
1146     left += dst[-1 + j * BPS];
1147   }
1148   {
1149     const int DC = _mm_cvtsi128_si32(sum) + left + 8;
1150     Put8x8uv_SSE2(DC >> 4, dst);
1151   }
1152 }
1153 
DC8uvNoLeft_SSE2(uint8_t * dst)1154 static void DC8uvNoLeft_SSE2(uint8_t* dst) {   // DC with no left samples
1155   const __m128i zero = _mm_setzero_si128();
1156   const __m128i top = _mm_loadl_epi64((const __m128i*)(dst - BPS));
1157   const __m128i sum = _mm_sad_epu8(top, zero);
1158   const int DC = _mm_cvtsi128_si32(sum) + 4;
1159   Put8x8uv_SSE2(DC >> 3, dst);
1160 }
1161 
DC8uvNoTop_SSE2(uint8_t * dst)1162 static void DC8uvNoTop_SSE2(uint8_t* dst) {  // DC with no top samples
1163   int dc0 = 4;
1164   int i;
1165   for (i = 0; i < 8; ++i) {
1166     dc0 += dst[-1 + i * BPS];
1167   }
1168   Put8x8uv_SSE2(dc0 >> 3, dst);
1169 }
1170 
DC8uvNoTopLeft_SSE2(uint8_t * dst)1171 static void DC8uvNoTopLeft_SSE2(uint8_t* dst) {    // DC with nothing
1172   Put8x8uv_SSE2(0x80, dst);
1173 }
1174 
1175 //------------------------------------------------------------------------------
1176 // Entry point
1177 
1178 extern void VP8DspInitSSE2(void);
1179 
VP8DspInitSSE2(void)1180 WEBP_TSAN_IGNORE_FUNCTION void VP8DspInitSSE2(void) {
1181   VP8Transform = Transform_SSE2;
1182 #if (USE_TRANSFORM_AC3 == 1)
1183   VP8TransformAC3 = TransformAC3_SSE2;
1184 #endif
1185 
1186   VP8VFilter16 = VFilter16_SSE2;
1187   VP8HFilter16 = HFilter16_SSE2;
1188   VP8VFilter8 = VFilter8_SSE2;
1189   VP8HFilter8 = HFilter8_SSE2;
1190   VP8VFilter16i = VFilter16i_SSE2;
1191   VP8HFilter16i = HFilter16i_SSE2;
1192   VP8VFilter8i = VFilter8i_SSE2;
1193   VP8HFilter8i = HFilter8i_SSE2;
1194 
1195   VP8SimpleVFilter16 = SimpleVFilter16_SSE2;
1196   VP8SimpleHFilter16 = SimpleHFilter16_SSE2;
1197   VP8SimpleVFilter16i = SimpleVFilter16i_SSE2;
1198   VP8SimpleHFilter16i = SimpleHFilter16i_SSE2;
1199 
1200   VP8PredLuma4[1] = TM4_SSE2;
1201   VP8PredLuma4[2] = VE4_SSE2;
1202   VP8PredLuma4[4] = RD4_SSE2;
1203   VP8PredLuma4[5] = VR4_SSE2;
1204   VP8PredLuma4[6] = LD4_SSE2;
1205   VP8PredLuma4[7] = VL4_SSE2;
1206 
1207   VP8PredLuma16[0] = DC16_SSE2;
1208   VP8PredLuma16[1] = TM16_SSE2;
1209   VP8PredLuma16[2] = VE16_SSE2;
1210   VP8PredLuma16[3] = HE16_SSE2;
1211   VP8PredLuma16[4] = DC16NoTop_SSE2;
1212   VP8PredLuma16[5] = DC16NoLeft_SSE2;
1213   VP8PredLuma16[6] = DC16NoTopLeft_SSE2;
1214 
1215   VP8PredChroma8[0] = DC8uv_SSE2;
1216   VP8PredChroma8[1] = TM8uv_SSE2;
1217   VP8PredChroma8[2] = VE8uv_SSE2;
1218   VP8PredChroma8[4] = DC8uvNoTop_SSE2;
1219   VP8PredChroma8[5] = DC8uvNoLeft_SSE2;
1220   VP8PredChroma8[6] = DC8uvNoTopLeft_SSE2;
1221 }
1222 
1223 #else  // !WEBP_USE_SSE2
1224 
1225 WEBP_DSP_INIT_STUB(VP8DspInitSSE2)
1226 
1227 #endif  // WEBP_USE_SSE2
1228