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 | |
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(WebPMemToInt32(dst + 0 * BPS)); |
162 | dst1 = _mm_cvtsi32_si128(WebPMemToInt32(dst + 1 * BPS)); |
163 | dst2 = _mm_cvtsi32_si128(WebPMemToInt32(dst + 2 * BPS)); |
164 | dst3 = _mm_cvtsi32_si128(WebPMemToInt32(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 | WebPInt32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(dst0)); |
191 | WebPInt32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(dst1)); |
192 | WebPInt32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(dst2)); |
193 | WebPInt32ToMem(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) |
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(WebPMemToInt32(dst + 0 * BPS)); |
217 | __m128i dst1 = _mm_cvtsi32_si128(WebPMemToInt32(dst + 1 * BPS)); |
218 | __m128i dst2 = _mm_cvtsi32_si128(WebPMemToInt32(dst + 2 * BPS)); |
219 | __m128i dst3 = _mm_cvtsi32_si128(WebPMemToInt32(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 | WebPInt32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(dst0)); |
237 | WebPInt32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(dst1)); |
238 | WebPInt32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(dst2)); |
239 | WebPInt32ToMem(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. |
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 |
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 |
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 |
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). |
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((char)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 |
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((char)thresh); |
342 | const __m128i t1 = MM_ABS(*p1, *q1); // abs(p1 - q1) |
343 | const __m128i kFE = _mm_set1_epi8((char)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) |
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((char)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) |
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((char)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, ¬_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) |
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((char)0x80); |
431 | __m128i a, not_hev; |
432 | |
433 | // compute hev mask |
434 | GetNotHEV_SSE2(p1, p0, q0, q1, hev_thresh, ¬_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. |
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 | WebPMemToInt32(&b[6 * stride]), WebPMemToInt32(&b[2 * stride]), |
481 | WebPMemToInt32(&b[4 * stride]), WebPMemToInt32(&b[0 * stride])); |
482 | const __m128i A1 = _mm_set_epi32( |
483 | WebPMemToInt32(&b[7 * stride]), WebPMemToInt32(&b[3 * stride]), |
484 | WebPMemToInt32(&b[5 * stride]), WebPMemToInt32(&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 | |
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 | |
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 | WebPInt32ToMem(dst, _mm_cvtsi128_si32(*x)); |
544 | *x = _mm_srli_si128(*x, 4); |
545 | } |
546 | } |
547 | |
548 | // Transpose back and store |
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 | |
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 | |
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 | |
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 | |
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 | |
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 |
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 | |
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 |
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 | |
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 |
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 | |
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 | |
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 | |
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 | |
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 int vals = _mm_cvtsi128_si32(avg); |
912 | int i; |
913 | for (i = 0; i < 4; ++i) { |
914 | WebPInt32ToMem(dst + i * BPS, vals); |
915 | } |
916 | } |
917 | |
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 | WebPInt32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32( abcdefg )); |
929 | WebPInt32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 1))); |
930 | WebPInt32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 2))); |
931 | WebPInt32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 3))); |
932 | } |
933 | |
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, (short)(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 | WebPInt32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32( abcd )); |
950 | WebPInt32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32( efgh )); |
951 | WebPInt32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(_mm_slli_si128(abcd, 1))); |
952 | WebPInt32ToMem(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 | |
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 = |
974 | (uint32_t)_mm_cvtsi128_si32(_mm_srli_si128(avg4, 4)); |
975 | WebPInt32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32( avg1 )); |
976 | WebPInt32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32( avg4 )); |
977 | WebPInt32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(avg1, 1))); |
978 | WebPInt32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(avg4, 1))); |
979 | |
980 | // these two are hard to get and irregular |
981 | DST(3, 2) = (extra_out >> 0) & 0xff; |
982 | DST(3, 3) = (extra_out >> 8) & 0xff; |
983 | } |
984 | |
985 | static void RD4_SSE2(uint8_t* dst) { // Down-right |
986 | const __m128i one = _mm_set1_epi8(1); |
987 | const __m128i XABCD = _mm_loadl_epi64((__m128i*)(dst - BPS - 1)); |
988 | const __m128i ____XABCD = _mm_slli_si128(XABCD, 4); |
989 | const uint32_t I = dst[-1 + 0 * BPS]; |
990 | const uint32_t J = dst[-1 + 1 * BPS]; |
991 | const uint32_t K = dst[-1 + 2 * BPS]; |
992 | const uint32_t L = dst[-1 + 3 * BPS]; |
993 | const __m128i LKJI_____ = |
994 | _mm_cvtsi32_si128((int)(L | (K << 8) | (J << 16) | (I << 24))); |
995 | const __m128i LKJIXABCD = _mm_or_si128(LKJI_____, ____XABCD); |
996 | const __m128i KJIXABCD_ = _mm_srli_si128(LKJIXABCD, 1); |
997 | const __m128i JIXABCD__ = _mm_srli_si128(LKJIXABCD, 2); |
998 | const __m128i avg1 = _mm_avg_epu8(JIXABCD__, LKJIXABCD); |
999 | const __m128i lsb = _mm_and_si128(_mm_xor_si128(JIXABCD__, LKJIXABCD), one); |
1000 | const __m128i avg2 = _mm_subs_epu8(avg1, lsb); |
1001 | const __m128i abcdefg = _mm_avg_epu8(avg2, KJIXABCD_); |
1002 | WebPInt32ToMem(dst + 3 * BPS, _mm_cvtsi128_si32( abcdefg )); |
1003 | WebPInt32ToMem(dst + 2 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 1))); |
1004 | WebPInt32ToMem(dst + 1 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 2))); |
1005 | WebPInt32ToMem(dst + 0 * BPS, _mm_cvtsi128_si32(_mm_srli_si128(abcdefg, 3))); |
1006 | } |
1007 | |
1008 | #undef DST |
1009 | #undef AVG3 |
1010 | |
1011 | //------------------------------------------------------------------------------ |
1012 | // Luma 16x16 |
1013 | |
1014 | static WEBP_INLINE void TrueMotion_SSE2(uint8_t* dst, int size) { |
1015 | const uint8_t* top = dst - BPS; |
1016 | const __m128i zero = _mm_setzero_si128(); |
1017 | int y; |
1018 | if (size == 4) { |
1019 | const __m128i top_values = _mm_cvtsi32_si128(WebPMemToInt32(top)); |
1020 | const __m128i top_base = _mm_unpacklo_epi8(top_values, zero); |
1021 | for (y = 0; y < 4; ++y, dst += BPS) { |
1022 | const int val = dst[-1] - top[-1]; |
1023 | const __m128i base = _mm_set1_epi16(val); |
1024 | const __m128i out = _mm_packus_epi16(_mm_add_epi16(base, top_base), zero); |
1025 | WebPInt32ToMem(dst, _mm_cvtsi128_si32(out)); |
1026 | } |
1027 | } else if (size == 8) { |
1028 | const __m128i top_values = _mm_loadl_epi64((const __m128i*)top); |
1029 | const __m128i top_base = _mm_unpacklo_epi8(top_values, zero); |
1030 | for (y = 0; y < 8; ++y, dst += BPS) { |
1031 | const int val = dst[-1] - top[-1]; |
1032 | const __m128i base = _mm_set1_epi16(val); |
1033 | const __m128i out = _mm_packus_epi16(_mm_add_epi16(base, top_base), zero); |
1034 | _mm_storel_epi64((__m128i*)dst, out); |
1035 | } |
1036 | } else { |
1037 | const __m128i top_values = _mm_loadu_si128((const __m128i*)top); |
1038 | const __m128i top_base_0 = _mm_unpacklo_epi8(top_values, zero); |
1039 | const __m128i top_base_1 = _mm_unpackhi_epi8(top_values, zero); |
1040 | for (y = 0; y < 16; ++y, dst += BPS) { |
1041 | const int val = dst[-1] - top[-1]; |
1042 | const __m128i base = _mm_set1_epi16(val); |
1043 | const __m128i out_0 = _mm_add_epi16(base, top_base_0); |
1044 | const __m128i out_1 = _mm_add_epi16(base, top_base_1); |
1045 | const __m128i out = _mm_packus_epi16(out_0, out_1); |
1046 | _mm_storeu_si128((__m128i*)dst, out); |
1047 | } |
1048 | } |
1049 | } |
1050 | |
1051 | static void TM4_SSE2(uint8_t* dst) { TrueMotion_SSE2(dst, 4); } |
1052 | static void TM8uv_SSE2(uint8_t* dst) { TrueMotion_SSE2(dst, 8); } |
1053 | static void TM16_SSE2(uint8_t* dst) { TrueMotion_SSE2(dst, 16); } |
1054 | |
1055 | static void VE16_SSE2(uint8_t* dst) { |
1056 | const __m128i top = _mm_loadu_si128((const __m128i*)(dst - BPS)); |
1057 | int j; |
1058 | for (j = 0; j < 16; ++j) { |
1059 | _mm_storeu_si128((__m128i*)(dst + j * BPS), top); |
1060 | } |
1061 | } |
1062 | |
1063 | static void HE16_SSE2(uint8_t* dst) { // horizontal |
1064 | int j; |
1065 | for (j = 16; j > 0; --j) { |
1066 | const __m128i values = _mm_set1_epi8((char)dst[-1]); |
1067 | _mm_storeu_si128((__m128i*)dst, values); |
1068 | dst += BPS; |
1069 | } |
1070 | } |
1071 | |
1072 | static WEBP_INLINE void Put16_SSE2(uint8_t v, uint8_t* dst) { |
1073 | int j; |
1074 | const __m128i values = _mm_set1_epi8((char)v); |
1075 | for (j = 0; j < 16; ++j) { |
1076 | _mm_storeu_si128((__m128i*)(dst + j * BPS), values); |
1077 | } |
1078 | } |
1079 | |
1080 | static void DC16_SSE2(uint8_t* dst) { // DC |
1081 | const __m128i zero = _mm_setzero_si128(); |
1082 | const __m128i top = _mm_loadu_si128((const __m128i*)(dst - BPS)); |
1083 | const __m128i sad8x2 = _mm_sad_epu8(top, zero); |
1084 | // sum the two sads: sad8x2[0:1] + sad8x2[8:9] |
1085 | const __m128i sum = _mm_add_epi16(sad8x2, _mm_shuffle_epi32(sad8x2, 2)); |
1086 | int left = 0; |
1087 | int j; |
1088 | for (j = 0; j < 16; ++j) { |
1089 | left += dst[-1 + j * BPS]; |
1090 | } |
1091 | { |
1092 | const int DC = _mm_cvtsi128_si32(sum) + left + 16; |
1093 | Put16_SSE2(DC >> 5, dst); |
1094 | } |
1095 | } |
1096 | |
1097 | static void DC16NoTop_SSE2(uint8_t* dst) { // DC with top samples unavailable |
1098 | int DC = 8; |
1099 | int j; |
1100 | for (j = 0; j < 16; ++j) { |
1101 | DC += dst[-1 + j * BPS]; |
1102 | } |
1103 | Put16_SSE2(DC >> 4, dst); |
1104 | } |
1105 | |
1106 | static void DC16NoLeft_SSE2(uint8_t* dst) { // DC with left samples unavailable |
1107 | const __m128i zero = _mm_setzero_si128(); |
1108 | const __m128i top = _mm_loadu_si128((const __m128i*)(dst - BPS)); |
1109 | const __m128i sad8x2 = _mm_sad_epu8(top, zero); |
1110 | // sum the two sads: sad8x2[0:1] + sad8x2[8:9] |
1111 | const __m128i sum = _mm_add_epi16(sad8x2, _mm_shuffle_epi32(sad8x2, 2)); |
1112 | const int DC = _mm_cvtsi128_si32(sum) + 8; |
1113 | Put16_SSE2(DC >> 4, dst); |
1114 | } |
1115 | |
1116 | static void DC16NoTopLeft_SSE2(uint8_t* dst) { // DC with no top & left samples |
1117 | Put16_SSE2(0x80, dst); |
1118 | } |
1119 | |
1120 | //------------------------------------------------------------------------------ |
1121 | // Chroma |
1122 | |
1123 | static void VE8uv_SSE2(uint8_t* dst) { // vertical |
1124 | int j; |
1125 | const __m128i top = _mm_loadl_epi64((const __m128i*)(dst - BPS)); |
1126 | for (j = 0; j < 8; ++j) { |
1127 | _mm_storel_epi64((__m128i*)(dst + j * BPS), top); |
1128 | } |
1129 | } |
1130 | |
1131 | // helper for chroma-DC predictions |
1132 | static WEBP_INLINE void Put8x8uv_SSE2(uint8_t v, uint8_t* dst) { |
1133 | int j; |
1134 | const __m128i values = _mm_set1_epi8((char)v); |
1135 | for (j = 0; j < 8; ++j) { |
1136 | _mm_storel_epi64((__m128i*)(dst + j * BPS), values); |
1137 | } |
1138 | } |
1139 | |
1140 | static void DC8uv_SSE2(uint8_t* dst) { // DC |
1141 | const __m128i zero = _mm_setzero_si128(); |
1142 | const __m128i top = _mm_loadl_epi64((const __m128i*)(dst - BPS)); |
1143 | const __m128i sum = _mm_sad_epu8(top, zero); |
1144 | int left = 0; |
1145 | int j; |
1146 | for (j = 0; j < 8; ++j) { |
1147 | left += dst[-1 + j * BPS]; |
1148 | } |
1149 | { |
1150 | const int DC = _mm_cvtsi128_si32(sum) + left + 8; |
1151 | Put8x8uv_SSE2(DC >> 4, dst); |
1152 | } |
1153 | } |
1154 | |
1155 | static void DC8uvNoLeft_SSE2(uint8_t* dst) { // DC with no left samples |
1156 | const __m128i zero = _mm_setzero_si128(); |
1157 | const __m128i top = _mm_loadl_epi64((const __m128i*)(dst - BPS)); |
1158 | const __m128i sum = _mm_sad_epu8(top, zero); |
1159 | const int DC = _mm_cvtsi128_si32(sum) + 4; |
1160 | Put8x8uv_SSE2(DC >> 3, dst); |
1161 | } |
1162 | |
1163 | static void DC8uvNoTop_SSE2(uint8_t* dst) { // DC with no top samples |
1164 | int dc0 = 4; |
1165 | int i; |
1166 | for (i = 0; i < 8; ++i) { |
1167 | dc0 += dst[-1 + i * BPS]; |
1168 | } |
1169 | Put8x8uv_SSE2(dc0 >> 3, dst); |
1170 | } |
1171 | |
1172 | static void DC8uvNoTopLeft_SSE2(uint8_t* dst) { // DC with nothing |
1173 | Put8x8uv_SSE2(0x80, dst); |
1174 | } |
1175 | |
1176 | //------------------------------------------------------------------------------ |
1177 | // Entry point |
1178 | |
1179 | extern void VP8DspInitSSE2(void); |
1180 | |
1181 | WEBP_TSAN_IGNORE_FUNCTION void VP8DspInitSSE2(void) { |
1182 | VP8Transform = Transform_SSE2; |
1183 | #if (USE_TRANSFORM_AC3 == 1) |
1184 | VP8TransformAC3 = TransformAC3_SSE2; |
1185 | #endif |
1186 | |
1187 | VP8VFilter16 = VFilter16_SSE2; |
1188 | VP8HFilter16 = HFilter16_SSE2; |
1189 | VP8VFilter8 = VFilter8_SSE2; |
1190 | VP8HFilter8 = HFilter8_SSE2; |
1191 | VP8VFilter16i = VFilter16i_SSE2; |
1192 | VP8HFilter16i = HFilter16i_SSE2; |
1193 | VP8VFilter8i = VFilter8i_SSE2; |
1194 | VP8HFilter8i = HFilter8i_SSE2; |
1195 | |
1196 | VP8SimpleVFilter16 = SimpleVFilter16_SSE2; |
1197 | VP8SimpleHFilter16 = SimpleHFilter16_SSE2; |
1198 | VP8SimpleVFilter16i = SimpleVFilter16i_SSE2; |
1199 | VP8SimpleHFilter16i = SimpleHFilter16i_SSE2; |
1200 | |
1201 | VP8PredLuma4[1] = TM4_SSE2; |
1202 | VP8PredLuma4[2] = VE4_SSE2; |
1203 | VP8PredLuma4[4] = RD4_SSE2; |
1204 | VP8PredLuma4[5] = VR4_SSE2; |
1205 | VP8PredLuma4[6] = LD4_SSE2; |
1206 | VP8PredLuma4[7] = VL4_SSE2; |
1207 | |
1208 | VP8PredLuma16[0] = DC16_SSE2; |
1209 | VP8PredLuma16[1] = TM16_SSE2; |
1210 | VP8PredLuma16[2] = VE16_SSE2; |
1211 | VP8PredLuma16[3] = HE16_SSE2; |
1212 | VP8PredLuma16[4] = DC16NoTop_SSE2; |
1213 | VP8PredLuma16[5] = DC16NoLeft_SSE2; |
1214 | VP8PredLuma16[6] = DC16NoTopLeft_SSE2; |
1215 | |
1216 | VP8PredChroma8[0] = DC8uv_SSE2; |
1217 | VP8PredChroma8[1] = TM8uv_SSE2; |
1218 | VP8PredChroma8[2] = VE8uv_SSE2; |
1219 | VP8PredChroma8[4] = DC8uvNoTop_SSE2; |
1220 | VP8PredChroma8[5] = DC8uvNoLeft_SSE2; |
1221 | VP8PredChroma8[6] = DC8uvNoTopLeft_SSE2; |
1222 | } |
1223 | |
1224 | #else // !WEBP_USE_SSE2 |
1225 | |
1226 | WEBP_DSP_INIT_STUB(VP8DspInitSSE2) |
1227 | |
1228 | #endif // WEBP_USE_SSE2 |
1229 | |