1 // Copyright 2015 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 variant of methods for lossless encoder
11 //
12 // Author: Skal (pascal.massimino@gmail.com)
13
14 #include "src/dsp/dsp.h"
15
16 #if defined(WEBP_USE_SSE2)
17 #include <assert.h>
18 #include <emmintrin.h>
19 #include "src/dsp/lossless.h"
20 #include "src/dsp/common_sse2.h"
21 #include "src/dsp/lossless_common.h"
22
23 // For sign-extended multiplying constants, pre-shifted by 5:
24 #define CST_5b(X) (((int16_t)((uint16_t)(X) << 8)) >> 5)
25
26 //------------------------------------------------------------------------------
27 // Subtract-Green Transform
28
SubtractGreenFromBlueAndRed_SSE2(uint32_t * argb_data,int num_pixels)29 static void SubtractGreenFromBlueAndRed_SSE2(uint32_t* argb_data,
30 int num_pixels) {
31 int i;
32 for (i = 0; i + 4 <= num_pixels; i += 4) {
33 const __m128i in = _mm_loadu_si128((__m128i*)&argb_data[i]); // argb
34 const __m128i A = _mm_srli_epi16(in, 8); // 0 a 0 g
35 const __m128i B = _mm_shufflelo_epi16(A, _MM_SHUFFLE(2, 2, 0, 0));
36 const __m128i C = _mm_shufflehi_epi16(B, _MM_SHUFFLE(2, 2, 0, 0)); // 0g0g
37 const __m128i out = _mm_sub_epi8(in, C);
38 _mm_storeu_si128((__m128i*)&argb_data[i], out);
39 }
40 // fallthrough and finish off with plain-C
41 if (i != num_pixels) {
42 VP8LSubtractGreenFromBlueAndRed_C(argb_data + i, num_pixels - i);
43 }
44 }
45
46 //------------------------------------------------------------------------------
47 // Color Transform
48
49 #define MK_CST_16(HI, LO) \
50 _mm_set1_epi32((int)(((uint32_t)(HI) << 16) | ((LO) & 0xffff)))
51
TransformColor_SSE2(const VP8LMultipliers * WEBP_RESTRICT const m,uint32_t * WEBP_RESTRICT argb_data,int num_pixels)52 static void TransformColor_SSE2(const VP8LMultipliers* WEBP_RESTRICT const m,
53 uint32_t* WEBP_RESTRICT argb_data,
54 int num_pixels) {
55 const __m128i mults_rb = MK_CST_16(CST_5b(m->green_to_red_),
56 CST_5b(m->green_to_blue_));
57 const __m128i mults_b2 = MK_CST_16(CST_5b(m->red_to_blue_), 0);
58 const __m128i mask_ag = _mm_set1_epi32((int)0xff00ff00); // alpha-green masks
59 const __m128i mask_rb = _mm_set1_epi32(0x00ff00ff); // red-blue masks
60 int i;
61 for (i = 0; i + 4 <= num_pixels; i += 4) {
62 const __m128i in = _mm_loadu_si128((__m128i*)&argb_data[i]); // argb
63 const __m128i A = _mm_and_si128(in, mask_ag); // a 0 g 0
64 const __m128i B = _mm_shufflelo_epi16(A, _MM_SHUFFLE(2, 2, 0, 0));
65 const __m128i C = _mm_shufflehi_epi16(B, _MM_SHUFFLE(2, 2, 0, 0)); // g0g0
66 const __m128i D = _mm_mulhi_epi16(C, mults_rb); // x dr x db1
67 const __m128i E = _mm_slli_epi16(in, 8); // r 0 b 0
68 const __m128i F = _mm_mulhi_epi16(E, mults_b2); // x db2 0 0
69 const __m128i G = _mm_srli_epi32(F, 16); // 0 0 x db2
70 const __m128i H = _mm_add_epi8(G, D); // x dr x db
71 const __m128i I = _mm_and_si128(H, mask_rb); // 0 dr 0 db
72 const __m128i out = _mm_sub_epi8(in, I);
73 _mm_storeu_si128((__m128i*)&argb_data[i], out);
74 }
75 // fallthrough and finish off with plain-C
76 if (i != num_pixels) {
77 VP8LTransformColor_C(m, argb_data + i, num_pixels - i);
78 }
79 }
80
81 //------------------------------------------------------------------------------
82 #define SPAN 8
CollectColorBlueTransforms_SSE2(const uint32_t * WEBP_RESTRICT argb,int stride,int tile_width,int tile_height,int green_to_blue,int red_to_blue,uint32_t histo[])83 static void CollectColorBlueTransforms_SSE2(const uint32_t* WEBP_RESTRICT argb,
84 int stride,
85 int tile_width, int tile_height,
86 int green_to_blue, int red_to_blue,
87 uint32_t histo[]) {
88 const __m128i mults_r = MK_CST_16(CST_5b(red_to_blue), 0);
89 const __m128i mults_g = MK_CST_16(0, CST_5b(green_to_blue));
90 const __m128i mask_g = _mm_set1_epi32(0x00ff00); // green mask
91 const __m128i mask_b = _mm_set1_epi32(0x0000ff); // blue mask
92 int y;
93 for (y = 0; y < tile_height; ++y) {
94 const uint32_t* const src = argb + y * stride;
95 int i, x;
96 for (x = 0; x + SPAN <= tile_width; x += SPAN) {
97 uint16_t values[SPAN];
98 const __m128i in0 = _mm_loadu_si128((__m128i*)&src[x + 0]);
99 const __m128i in1 = _mm_loadu_si128((__m128i*)&src[x + SPAN / 2]);
100 const __m128i A0 = _mm_slli_epi16(in0, 8); // r 0 | b 0
101 const __m128i A1 = _mm_slli_epi16(in1, 8);
102 const __m128i B0 = _mm_and_si128(in0, mask_g); // 0 0 | g 0
103 const __m128i B1 = _mm_and_si128(in1, mask_g);
104 const __m128i C0 = _mm_mulhi_epi16(A0, mults_r); // x db | 0 0
105 const __m128i C1 = _mm_mulhi_epi16(A1, mults_r);
106 const __m128i D0 = _mm_mulhi_epi16(B0, mults_g); // 0 0 | x db
107 const __m128i D1 = _mm_mulhi_epi16(B1, mults_g);
108 const __m128i E0 = _mm_sub_epi8(in0, D0); // x x | x b'
109 const __m128i E1 = _mm_sub_epi8(in1, D1);
110 const __m128i F0 = _mm_srli_epi32(C0, 16); // 0 0 | x db
111 const __m128i F1 = _mm_srli_epi32(C1, 16);
112 const __m128i G0 = _mm_sub_epi8(E0, F0); // 0 0 | x b'
113 const __m128i G1 = _mm_sub_epi8(E1, F1);
114 const __m128i H0 = _mm_and_si128(G0, mask_b); // 0 0 | 0 b
115 const __m128i H1 = _mm_and_si128(G1, mask_b);
116 const __m128i I = _mm_packs_epi32(H0, H1); // 0 b' | 0 b'
117 _mm_storeu_si128((__m128i*)values, I);
118 for (i = 0; i < SPAN; ++i) ++histo[values[i]];
119 }
120 }
121 {
122 const int left_over = tile_width & (SPAN - 1);
123 if (left_over > 0) {
124 VP8LCollectColorBlueTransforms_C(argb + tile_width - left_over, stride,
125 left_over, tile_height,
126 green_to_blue, red_to_blue, histo);
127 }
128 }
129 }
130
CollectColorRedTransforms_SSE2(const uint32_t * WEBP_RESTRICT argb,int stride,int tile_width,int tile_height,int green_to_red,uint32_t histo[])131 static void CollectColorRedTransforms_SSE2(const uint32_t* WEBP_RESTRICT argb,
132 int stride,
133 int tile_width, int tile_height,
134 int green_to_red, uint32_t histo[]) {
135 const __m128i mults_g = MK_CST_16(0, CST_5b(green_to_red));
136 const __m128i mask_g = _mm_set1_epi32(0x00ff00); // green mask
137 const __m128i mask = _mm_set1_epi32(0xff);
138
139 int y;
140 for (y = 0; y < tile_height; ++y) {
141 const uint32_t* const src = argb + y * stride;
142 int i, x;
143 for (x = 0; x + SPAN <= tile_width; x += SPAN) {
144 uint16_t values[SPAN];
145 const __m128i in0 = _mm_loadu_si128((__m128i*)&src[x + 0]);
146 const __m128i in1 = _mm_loadu_si128((__m128i*)&src[x + SPAN / 2]);
147 const __m128i A0 = _mm_and_si128(in0, mask_g); // 0 0 | g 0
148 const __m128i A1 = _mm_and_si128(in1, mask_g);
149 const __m128i B0 = _mm_srli_epi32(in0, 16); // 0 0 | x r
150 const __m128i B1 = _mm_srli_epi32(in1, 16);
151 const __m128i C0 = _mm_mulhi_epi16(A0, mults_g); // 0 0 | x dr
152 const __m128i C1 = _mm_mulhi_epi16(A1, mults_g);
153 const __m128i E0 = _mm_sub_epi8(B0, C0); // x x | x r'
154 const __m128i E1 = _mm_sub_epi8(B1, C1);
155 const __m128i F0 = _mm_and_si128(E0, mask); // 0 0 | 0 r'
156 const __m128i F1 = _mm_and_si128(E1, mask);
157 const __m128i I = _mm_packs_epi32(F0, F1);
158 _mm_storeu_si128((__m128i*)values, I);
159 for (i = 0; i < SPAN; ++i) ++histo[values[i]];
160 }
161 }
162 {
163 const int left_over = tile_width & (SPAN - 1);
164 if (left_over > 0) {
165 VP8LCollectColorRedTransforms_C(argb + tile_width - left_over, stride,
166 left_over, tile_height,
167 green_to_red, histo);
168 }
169 }
170 }
171 #undef SPAN
172 #undef MK_CST_16
173
174 //------------------------------------------------------------------------------
175
176 // Note we are adding uint32_t's as *signed* int32's (using _mm_add_epi32). But
177 // that's ok since the histogram values are less than 1<<28 (max picture size).
AddVector_SSE2(const uint32_t * WEBP_RESTRICT a,const uint32_t * WEBP_RESTRICT b,uint32_t * WEBP_RESTRICT out,int size)178 static void AddVector_SSE2(const uint32_t* WEBP_RESTRICT a,
179 const uint32_t* WEBP_RESTRICT b,
180 uint32_t* WEBP_RESTRICT out, int size) {
181 int i = 0;
182 int aligned_size = size & ~15;
183 // Size is, at minimum, NUM_DISTANCE_CODES (40) and may be as large as
184 // NUM_LITERAL_CODES (256) + NUM_LENGTH_CODES (24) + (0 or a non-zero power of
185 // 2). See the usage in VP8LHistogramAdd().
186 assert(size >= 16);
187 assert(size % 2 == 0);
188
189 do {
190 const __m128i a0 = _mm_loadu_si128((const __m128i*)&a[i + 0]);
191 const __m128i a1 = _mm_loadu_si128((const __m128i*)&a[i + 4]);
192 const __m128i a2 = _mm_loadu_si128((const __m128i*)&a[i + 8]);
193 const __m128i a3 = _mm_loadu_si128((const __m128i*)&a[i + 12]);
194 const __m128i b0 = _mm_loadu_si128((const __m128i*)&b[i + 0]);
195 const __m128i b1 = _mm_loadu_si128((const __m128i*)&b[i + 4]);
196 const __m128i b2 = _mm_loadu_si128((const __m128i*)&b[i + 8]);
197 const __m128i b3 = _mm_loadu_si128((const __m128i*)&b[i + 12]);
198 _mm_storeu_si128((__m128i*)&out[i + 0], _mm_add_epi32(a0, b0));
199 _mm_storeu_si128((__m128i*)&out[i + 4], _mm_add_epi32(a1, b1));
200 _mm_storeu_si128((__m128i*)&out[i + 8], _mm_add_epi32(a2, b2));
201 _mm_storeu_si128((__m128i*)&out[i + 12], _mm_add_epi32(a3, b3));
202 i += 16;
203 } while (i != aligned_size);
204
205 if ((size & 8) != 0) {
206 const __m128i a0 = _mm_loadu_si128((const __m128i*)&a[i + 0]);
207 const __m128i a1 = _mm_loadu_si128((const __m128i*)&a[i + 4]);
208 const __m128i b0 = _mm_loadu_si128((const __m128i*)&b[i + 0]);
209 const __m128i b1 = _mm_loadu_si128((const __m128i*)&b[i + 4]);
210 _mm_storeu_si128((__m128i*)&out[i + 0], _mm_add_epi32(a0, b0));
211 _mm_storeu_si128((__m128i*)&out[i + 4], _mm_add_epi32(a1, b1));
212 i += 8;
213 }
214
215 size &= 7;
216 if (size == 4) {
217 const __m128i a0 = _mm_loadu_si128((const __m128i*)&a[i]);
218 const __m128i b0 = _mm_loadu_si128((const __m128i*)&b[i]);
219 _mm_storeu_si128((__m128i*)&out[i], _mm_add_epi32(a0, b0));
220 } else if (size == 2) {
221 const __m128i a0 = _mm_loadl_epi64((const __m128i*)&a[i]);
222 const __m128i b0 = _mm_loadl_epi64((const __m128i*)&b[i]);
223 _mm_storel_epi64((__m128i*)&out[i], _mm_add_epi32(a0, b0));
224 }
225 }
226
AddVectorEq_SSE2(const uint32_t * WEBP_RESTRICT a,uint32_t * WEBP_RESTRICT out,int size)227 static void AddVectorEq_SSE2(const uint32_t* WEBP_RESTRICT a,
228 uint32_t* WEBP_RESTRICT out, int size) {
229 int i = 0;
230 int aligned_size = size & ~15;
231 // Size is, at minimum, NUM_DISTANCE_CODES (40) and may be as large as
232 // NUM_LITERAL_CODES (256) + NUM_LENGTH_CODES (24) + (0 or a non-zero power of
233 // 2). See the usage in VP8LHistogramAdd().
234 assert(size >= 16);
235 assert(size % 2 == 0);
236
237 do {
238 const __m128i a0 = _mm_loadu_si128((const __m128i*)&a[i + 0]);
239 const __m128i a1 = _mm_loadu_si128((const __m128i*)&a[i + 4]);
240 const __m128i a2 = _mm_loadu_si128((const __m128i*)&a[i + 8]);
241 const __m128i a3 = _mm_loadu_si128((const __m128i*)&a[i + 12]);
242 const __m128i b0 = _mm_loadu_si128((const __m128i*)&out[i + 0]);
243 const __m128i b1 = _mm_loadu_si128((const __m128i*)&out[i + 4]);
244 const __m128i b2 = _mm_loadu_si128((const __m128i*)&out[i + 8]);
245 const __m128i b3 = _mm_loadu_si128((const __m128i*)&out[i + 12]);
246 _mm_storeu_si128((__m128i*)&out[i + 0], _mm_add_epi32(a0, b0));
247 _mm_storeu_si128((__m128i*)&out[i + 4], _mm_add_epi32(a1, b1));
248 _mm_storeu_si128((__m128i*)&out[i + 8], _mm_add_epi32(a2, b2));
249 _mm_storeu_si128((__m128i*)&out[i + 12], _mm_add_epi32(a3, b3));
250 i += 16;
251 } while (i != aligned_size);
252
253 if ((size & 8) != 0) {
254 const __m128i a0 = _mm_loadu_si128((const __m128i*)&a[i + 0]);
255 const __m128i a1 = _mm_loadu_si128((const __m128i*)&a[i + 4]);
256 const __m128i b0 = _mm_loadu_si128((const __m128i*)&out[i + 0]);
257 const __m128i b1 = _mm_loadu_si128((const __m128i*)&out[i + 4]);
258 _mm_storeu_si128((__m128i*)&out[i + 0], _mm_add_epi32(a0, b0));
259 _mm_storeu_si128((__m128i*)&out[i + 4], _mm_add_epi32(a1, b1));
260 i += 8;
261 }
262
263 size &= 7;
264 if (size == 4) {
265 const __m128i a0 = _mm_loadu_si128((const __m128i*)&a[i]);
266 const __m128i b0 = _mm_loadu_si128((const __m128i*)&out[i]);
267 _mm_storeu_si128((__m128i*)&out[i], _mm_add_epi32(a0, b0));
268 } else if (size == 2) {
269 const __m128i a0 = _mm_loadl_epi64((const __m128i*)&a[i]);
270 const __m128i b0 = _mm_loadl_epi64((const __m128i*)&out[i]);
271 _mm_storel_epi64((__m128i*)&out[i], _mm_add_epi32(a0, b0));
272 }
273 }
274
275 //------------------------------------------------------------------------------
276 // Entropy
277
278 #if !defined(WEBP_HAVE_SLOW_CLZ_CTZ)
279
CombinedShannonEntropy_SSE2(const uint32_t X[256],const uint32_t Y[256])280 static uint64_t CombinedShannonEntropy_SSE2(const uint32_t X[256],
281 const uint32_t Y[256]) {
282 int i;
283 uint64_t retval = 0;
284 uint32_t sumX = 0, sumXY = 0;
285 const __m128i zero = _mm_setzero_si128();
286
287 for (i = 0; i < 256; i += 16) {
288 const __m128i x0 = _mm_loadu_si128((const __m128i*)(X + i + 0));
289 const __m128i y0 = _mm_loadu_si128((const __m128i*)(Y + i + 0));
290 const __m128i x1 = _mm_loadu_si128((const __m128i*)(X + i + 4));
291 const __m128i y1 = _mm_loadu_si128((const __m128i*)(Y + i + 4));
292 const __m128i x2 = _mm_loadu_si128((const __m128i*)(X + i + 8));
293 const __m128i y2 = _mm_loadu_si128((const __m128i*)(Y + i + 8));
294 const __m128i x3 = _mm_loadu_si128((const __m128i*)(X + i + 12));
295 const __m128i y3 = _mm_loadu_si128((const __m128i*)(Y + i + 12));
296 const __m128i x4 = _mm_packs_epi16(_mm_packs_epi32(x0, x1),
297 _mm_packs_epi32(x2, x3));
298 const __m128i y4 = _mm_packs_epi16(_mm_packs_epi32(y0, y1),
299 _mm_packs_epi32(y2, y3));
300 const int32_t mx = _mm_movemask_epi8(_mm_cmpgt_epi8(x4, zero));
301 int32_t my = _mm_movemask_epi8(_mm_cmpgt_epi8(y4, zero)) | mx;
302 while (my) {
303 const int32_t j = BitsCtz(my);
304 uint32_t xy;
305 if ((mx >> j) & 1) {
306 const int x = X[i + j];
307 sumXY += x;
308 retval += VP8LFastSLog2(x);
309 }
310 xy = X[i + j] + Y[i + j];
311 sumX += xy;
312 retval += VP8LFastSLog2(xy);
313 my &= my - 1;
314 }
315 }
316 retval = VP8LFastSLog2(sumX) + VP8LFastSLog2(sumXY) - retval;
317 return retval;
318 }
319
320 #else
321
322 #define DONT_USE_COMBINED_SHANNON_ENTROPY_SSE2_FUNC // won't be faster
323
324 #endif
325
326 //------------------------------------------------------------------------------
327
VectorMismatch_SSE2(const uint32_t * const array1,const uint32_t * const array2,int length)328 static int VectorMismatch_SSE2(const uint32_t* const array1,
329 const uint32_t* const array2, int length) {
330 int match_len;
331
332 if (length >= 12) {
333 __m128i A0 = _mm_loadu_si128((const __m128i*)&array1[0]);
334 __m128i A1 = _mm_loadu_si128((const __m128i*)&array2[0]);
335 match_len = 0;
336 do {
337 // Loop unrolling and early load both provide a speedup of 10% for the
338 // current function. Also, max_limit can be MAX_LENGTH=4096 at most.
339 const __m128i cmpA = _mm_cmpeq_epi32(A0, A1);
340 const __m128i B0 =
341 _mm_loadu_si128((const __m128i*)&array1[match_len + 4]);
342 const __m128i B1 =
343 _mm_loadu_si128((const __m128i*)&array2[match_len + 4]);
344 if (_mm_movemask_epi8(cmpA) != 0xffff) break;
345 match_len += 4;
346
347 {
348 const __m128i cmpB = _mm_cmpeq_epi32(B0, B1);
349 A0 = _mm_loadu_si128((const __m128i*)&array1[match_len + 4]);
350 A1 = _mm_loadu_si128((const __m128i*)&array2[match_len + 4]);
351 if (_mm_movemask_epi8(cmpB) != 0xffff) break;
352 match_len += 4;
353 }
354 } while (match_len + 12 < length);
355 } else {
356 match_len = 0;
357 // Unroll the potential first two loops.
358 if (length >= 4 &&
359 _mm_movemask_epi8(_mm_cmpeq_epi32(
360 _mm_loadu_si128((const __m128i*)&array1[0]),
361 _mm_loadu_si128((const __m128i*)&array2[0]))) == 0xffff) {
362 match_len = 4;
363 if (length >= 8 &&
364 _mm_movemask_epi8(_mm_cmpeq_epi32(
365 _mm_loadu_si128((const __m128i*)&array1[4]),
366 _mm_loadu_si128((const __m128i*)&array2[4]))) == 0xffff) {
367 match_len = 8;
368 }
369 }
370 }
371
372 while (match_len < length && array1[match_len] == array2[match_len]) {
373 ++match_len;
374 }
375 return match_len;
376 }
377
378 // Bundles multiple (1, 2, 4 or 8) pixels into a single pixel.
BundleColorMap_SSE2(const uint8_t * WEBP_RESTRICT const row,int width,int xbits,uint32_t * WEBP_RESTRICT dst)379 static void BundleColorMap_SSE2(const uint8_t* WEBP_RESTRICT const row,
380 int width, int xbits,
381 uint32_t* WEBP_RESTRICT dst) {
382 int x;
383 assert(xbits >= 0);
384 assert(xbits <= 3);
385 switch (xbits) {
386 case 0: {
387 const __m128i ff = _mm_set1_epi16((short)0xff00);
388 const __m128i zero = _mm_setzero_si128();
389 // Store 0xff000000 | (row[x] << 8).
390 for (x = 0; x + 16 <= width; x += 16, dst += 16) {
391 const __m128i in = _mm_loadu_si128((const __m128i*)&row[x]);
392 const __m128i in_lo = _mm_unpacklo_epi8(zero, in);
393 const __m128i dst0 = _mm_unpacklo_epi16(in_lo, ff);
394 const __m128i dst1 = _mm_unpackhi_epi16(in_lo, ff);
395 const __m128i in_hi = _mm_unpackhi_epi8(zero, in);
396 const __m128i dst2 = _mm_unpacklo_epi16(in_hi, ff);
397 const __m128i dst3 = _mm_unpackhi_epi16(in_hi, ff);
398 _mm_storeu_si128((__m128i*)&dst[0], dst0);
399 _mm_storeu_si128((__m128i*)&dst[4], dst1);
400 _mm_storeu_si128((__m128i*)&dst[8], dst2);
401 _mm_storeu_si128((__m128i*)&dst[12], dst3);
402 }
403 break;
404 }
405 case 1: {
406 const __m128i ff = _mm_set1_epi16((short)0xff00);
407 const __m128i mul = _mm_set1_epi16(0x110);
408 for (x = 0; x + 16 <= width; x += 16, dst += 8) {
409 // 0a0b | (where a/b are 4 bits).
410 const __m128i in = _mm_loadu_si128((const __m128i*)&row[x]);
411 const __m128i tmp = _mm_mullo_epi16(in, mul); // aba0
412 const __m128i pack = _mm_and_si128(tmp, ff); // ab00
413 const __m128i dst0 = _mm_unpacklo_epi16(pack, ff);
414 const __m128i dst1 = _mm_unpackhi_epi16(pack, ff);
415 _mm_storeu_si128((__m128i*)&dst[0], dst0);
416 _mm_storeu_si128((__m128i*)&dst[4], dst1);
417 }
418 break;
419 }
420 case 2: {
421 const __m128i mask_or = _mm_set1_epi32((int)0xff000000);
422 const __m128i mul_cst = _mm_set1_epi16(0x0104);
423 const __m128i mask_mul = _mm_set1_epi16(0x0f00);
424 for (x = 0; x + 16 <= width; x += 16, dst += 4) {
425 // 000a000b000c000d | (where a/b/c/d are 2 bits).
426 const __m128i in = _mm_loadu_si128((const __m128i*)&row[x]);
427 const __m128i mul = _mm_mullo_epi16(in, mul_cst); // 00ab00b000cd00d0
428 const __m128i tmp = _mm_and_si128(mul, mask_mul); // 00ab000000cd0000
429 const __m128i shift = _mm_srli_epi32(tmp, 12); // 00000000ab000000
430 const __m128i pack = _mm_or_si128(shift, tmp); // 00000000abcd0000
431 // Convert to 0xff00**00.
432 const __m128i res = _mm_or_si128(pack, mask_or);
433 _mm_storeu_si128((__m128i*)dst, res);
434 }
435 break;
436 }
437 default: {
438 assert(xbits == 3);
439 for (x = 0; x + 16 <= width; x += 16, dst += 2) {
440 // 0000000a00000000b... | (where a/b are 1 bit).
441 const __m128i in = _mm_loadu_si128((const __m128i*)&row[x]);
442 const __m128i shift = _mm_slli_epi64(in, 7);
443 const uint32_t move = _mm_movemask_epi8(shift);
444 dst[0] = 0xff000000 | ((move & 0xff) << 8);
445 dst[1] = 0xff000000 | (move & 0xff00);
446 }
447 break;
448 }
449 }
450 if (x != width) {
451 VP8LBundleColorMap_C(row + x, width - x, xbits, dst);
452 }
453 }
454
455 //------------------------------------------------------------------------------
456 // Batch version of Predictor Transform subtraction
457
Average2_m128i(const __m128i * const a0,const __m128i * const a1,__m128i * const avg)458 static WEBP_INLINE void Average2_m128i(const __m128i* const a0,
459 const __m128i* const a1,
460 __m128i* const avg) {
461 // (a + b) >> 1 = ((a + b + 1) >> 1) - ((a ^ b) & 1)
462 const __m128i ones = _mm_set1_epi8(1);
463 const __m128i avg1 = _mm_avg_epu8(*a0, *a1);
464 const __m128i one = _mm_and_si128(_mm_xor_si128(*a0, *a1), ones);
465 *avg = _mm_sub_epi8(avg1, one);
466 }
467
468 // Predictor0: ARGB_BLACK.
PredictorSub0_SSE2(const uint32_t * in,const uint32_t * upper,int num_pixels,uint32_t * WEBP_RESTRICT out)469 static void PredictorSub0_SSE2(const uint32_t* in, const uint32_t* upper,
470 int num_pixels, uint32_t* WEBP_RESTRICT out) {
471 int i;
472 const __m128i black = _mm_set1_epi32((int)ARGB_BLACK);
473 for (i = 0; i + 4 <= num_pixels; i += 4) {
474 const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
475 const __m128i res = _mm_sub_epi8(src, black);
476 _mm_storeu_si128((__m128i*)&out[i], res);
477 }
478 if (i != num_pixels) {
479 VP8LPredictorsSub_C[0](in + i, NULL, num_pixels - i, out + i);
480 }
481 (void)upper;
482 }
483
484 #define GENERATE_PREDICTOR_1(X, IN) \
485 static void PredictorSub##X##_SSE2(const uint32_t* const in, \
486 const uint32_t* const upper, \
487 int num_pixels, \
488 uint32_t* WEBP_RESTRICT const out) { \
489 int i; \
490 for (i = 0; i + 4 <= num_pixels; i += 4) { \
491 const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]); \
492 const __m128i pred = _mm_loadu_si128((const __m128i*)&(IN)); \
493 const __m128i res = _mm_sub_epi8(src, pred); \
494 _mm_storeu_si128((__m128i*)&out[i], res); \
495 } \
496 if (i != num_pixels) { \
497 VP8LPredictorsSub_C[(X)](in + i, WEBP_OFFSET_PTR(upper, i), \
498 num_pixels - i, out + i); \
499 } \
500 }
501
502 GENERATE_PREDICTOR_1(1, in[i - 1]) // Predictor1: L
503 GENERATE_PREDICTOR_1(2, upper[i]) // Predictor2: T
504 GENERATE_PREDICTOR_1(3, upper[i + 1]) // Predictor3: TR
505 GENERATE_PREDICTOR_1(4, upper[i - 1]) // Predictor4: TL
506 #undef GENERATE_PREDICTOR_1
507
508 // Predictor5: avg2(avg2(L, TR), T)
PredictorSub5_SSE2(const uint32_t * in,const uint32_t * upper,int num_pixels,uint32_t * WEBP_RESTRICT out)509 static void PredictorSub5_SSE2(const uint32_t* in, const uint32_t* upper,
510 int num_pixels, uint32_t* WEBP_RESTRICT out) {
511 int i;
512 for (i = 0; i + 4 <= num_pixels; i += 4) {
513 const __m128i L = _mm_loadu_si128((const __m128i*)&in[i - 1]);
514 const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
515 const __m128i TR = _mm_loadu_si128((const __m128i*)&upper[i + 1]);
516 const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
517 __m128i avg, pred, res;
518 Average2_m128i(&L, &TR, &avg);
519 Average2_m128i(&avg, &T, &pred);
520 res = _mm_sub_epi8(src, pred);
521 _mm_storeu_si128((__m128i*)&out[i], res);
522 }
523 if (i != num_pixels) {
524 VP8LPredictorsSub_C[5](in + i, upper + i, num_pixels - i, out + i);
525 }
526 }
527
528 #define GENERATE_PREDICTOR_2(X, A, B) \
529 static void PredictorSub##X##_SSE2(const uint32_t* in, const uint32_t* upper, \
530 int num_pixels, \
531 uint32_t* WEBP_RESTRICT out) { \
532 int i; \
533 for (i = 0; i + 4 <= num_pixels; i += 4) { \
534 const __m128i tA = _mm_loadu_si128((const __m128i*)&(A)); \
535 const __m128i tB = _mm_loadu_si128((const __m128i*)&(B)); \
536 const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]); \
537 __m128i pred, res; \
538 Average2_m128i(&tA, &tB, &pred); \
539 res = _mm_sub_epi8(src, pred); \
540 _mm_storeu_si128((__m128i*)&out[i], res); \
541 } \
542 if (i != num_pixels) { \
543 VP8LPredictorsSub_C[(X)](in + i, upper + i, num_pixels - i, out + i); \
544 } \
545 }
546
547 GENERATE_PREDICTOR_2(6, in[i - 1], upper[i - 1]) // Predictor6: avg(L, TL)
548 GENERATE_PREDICTOR_2(7, in[i - 1], upper[i]) // Predictor7: avg(L, T)
549 GENERATE_PREDICTOR_2(8, upper[i - 1], upper[i]) // Predictor8: avg(TL, T)
550 GENERATE_PREDICTOR_2(9, upper[i], upper[i + 1]) // Predictor9: average(T, TR)
551 #undef GENERATE_PREDICTOR_2
552
553 // Predictor10: avg(avg(L,TL), avg(T, TR)).
PredictorSub10_SSE2(const uint32_t * in,const uint32_t * upper,int num_pixels,uint32_t * WEBP_RESTRICT out)554 static void PredictorSub10_SSE2(const uint32_t* in, const uint32_t* upper,
555 int num_pixels, uint32_t* WEBP_RESTRICT out) {
556 int i;
557 for (i = 0; i + 4 <= num_pixels; i += 4) {
558 const __m128i L = _mm_loadu_si128((const __m128i*)&in[i - 1]);
559 const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
560 const __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);
561 const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
562 const __m128i TR = _mm_loadu_si128((const __m128i*)&upper[i + 1]);
563 __m128i avgTTR, avgLTL, avg, res;
564 Average2_m128i(&T, &TR, &avgTTR);
565 Average2_m128i(&L, &TL, &avgLTL);
566 Average2_m128i(&avgTTR, &avgLTL, &avg);
567 res = _mm_sub_epi8(src, avg);
568 _mm_storeu_si128((__m128i*)&out[i], res);
569 }
570 if (i != num_pixels) {
571 VP8LPredictorsSub_C[10](in + i, upper + i, num_pixels - i, out + i);
572 }
573 }
574
575 // Predictor11: select.
GetSumAbsDiff32_SSE2(const __m128i * const A,const __m128i * const B,__m128i * const out)576 static void GetSumAbsDiff32_SSE2(const __m128i* const A, const __m128i* const B,
577 __m128i* const out) {
578 // We can unpack with any value on the upper 32 bits, provided it's the same
579 // on both operands (to that their sum of abs diff is zero). Here we use *A.
580 const __m128i A_lo = _mm_unpacklo_epi32(*A, *A);
581 const __m128i B_lo = _mm_unpacklo_epi32(*B, *A);
582 const __m128i A_hi = _mm_unpackhi_epi32(*A, *A);
583 const __m128i B_hi = _mm_unpackhi_epi32(*B, *A);
584 const __m128i s_lo = _mm_sad_epu8(A_lo, B_lo);
585 const __m128i s_hi = _mm_sad_epu8(A_hi, B_hi);
586 *out = _mm_packs_epi32(s_lo, s_hi);
587 }
588
PredictorSub11_SSE2(const uint32_t * in,const uint32_t * upper,int num_pixels,uint32_t * WEBP_RESTRICT out)589 static void PredictorSub11_SSE2(const uint32_t* in, const uint32_t* upper,
590 int num_pixels, uint32_t* WEBP_RESTRICT out) {
591 int i;
592 for (i = 0; i + 4 <= num_pixels; i += 4) {
593 const __m128i L = _mm_loadu_si128((const __m128i*)&in[i - 1]);
594 const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
595 const __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);
596 const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
597 __m128i pa, pb;
598 GetSumAbsDiff32_SSE2(&T, &TL, &pa); // pa = sum |T-TL|
599 GetSumAbsDiff32_SSE2(&L, &TL, &pb); // pb = sum |L-TL|
600 {
601 const __m128i mask = _mm_cmpgt_epi32(pb, pa);
602 const __m128i A = _mm_and_si128(mask, L);
603 const __m128i B = _mm_andnot_si128(mask, T);
604 const __m128i pred = _mm_or_si128(A, B); // pred = (L > T)? L : T
605 const __m128i res = _mm_sub_epi8(src, pred);
606 _mm_storeu_si128((__m128i*)&out[i], res);
607 }
608 }
609 if (i != num_pixels) {
610 VP8LPredictorsSub_C[11](in + i, upper + i, num_pixels - i, out + i);
611 }
612 }
613
614 // Predictor12: ClampedSubSubtractFull.
PredictorSub12_SSE2(const uint32_t * in,const uint32_t * upper,int num_pixels,uint32_t * WEBP_RESTRICT out)615 static void PredictorSub12_SSE2(const uint32_t* in, const uint32_t* upper,
616 int num_pixels, uint32_t* WEBP_RESTRICT out) {
617 int i;
618 const __m128i zero = _mm_setzero_si128();
619 for (i = 0; i + 4 <= num_pixels; i += 4) {
620 const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
621 const __m128i L = _mm_loadu_si128((const __m128i*)&in[i - 1]);
622 const __m128i L_lo = _mm_unpacklo_epi8(L, zero);
623 const __m128i L_hi = _mm_unpackhi_epi8(L, zero);
624 const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
625 const __m128i T_lo = _mm_unpacklo_epi8(T, zero);
626 const __m128i T_hi = _mm_unpackhi_epi8(T, zero);
627 const __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);
628 const __m128i TL_lo = _mm_unpacklo_epi8(TL, zero);
629 const __m128i TL_hi = _mm_unpackhi_epi8(TL, zero);
630 const __m128i diff_lo = _mm_sub_epi16(T_lo, TL_lo);
631 const __m128i diff_hi = _mm_sub_epi16(T_hi, TL_hi);
632 const __m128i pred_lo = _mm_add_epi16(L_lo, diff_lo);
633 const __m128i pred_hi = _mm_add_epi16(L_hi, diff_hi);
634 const __m128i pred = _mm_packus_epi16(pred_lo, pred_hi);
635 const __m128i res = _mm_sub_epi8(src, pred);
636 _mm_storeu_si128((__m128i*)&out[i], res);
637 }
638 if (i != num_pixels) {
639 VP8LPredictorsSub_C[12](in + i, upper + i, num_pixels - i, out + i);
640 }
641 }
642
643 // Predictors13: ClampedAddSubtractHalf
PredictorSub13_SSE2(const uint32_t * in,const uint32_t * upper,int num_pixels,uint32_t * WEBP_RESTRICT out)644 static void PredictorSub13_SSE2(const uint32_t* in, const uint32_t* upper,
645 int num_pixels, uint32_t* WEBP_RESTRICT out) {
646 int i;
647 const __m128i zero = _mm_setzero_si128();
648 for (i = 0; i + 2 <= num_pixels; i += 2) {
649 // we can only process two pixels at a time
650 const __m128i L = _mm_loadl_epi64((const __m128i*)&in[i - 1]);
651 const __m128i src = _mm_loadl_epi64((const __m128i*)&in[i]);
652 const __m128i T = _mm_loadl_epi64((const __m128i*)&upper[i]);
653 const __m128i TL = _mm_loadl_epi64((const __m128i*)&upper[i - 1]);
654 const __m128i L_lo = _mm_unpacklo_epi8(L, zero);
655 const __m128i T_lo = _mm_unpacklo_epi8(T, zero);
656 const __m128i TL_lo = _mm_unpacklo_epi8(TL, zero);
657 const __m128i sum = _mm_add_epi16(T_lo, L_lo);
658 const __m128i avg = _mm_srli_epi16(sum, 1);
659 const __m128i A1 = _mm_sub_epi16(avg, TL_lo);
660 const __m128i bit_fix = _mm_cmpgt_epi16(TL_lo, avg);
661 const __m128i A2 = _mm_sub_epi16(A1, bit_fix);
662 const __m128i A3 = _mm_srai_epi16(A2, 1);
663 const __m128i A4 = _mm_add_epi16(avg, A3);
664 const __m128i pred = _mm_packus_epi16(A4, A4);
665 const __m128i res = _mm_sub_epi8(src, pred);
666 _mm_storel_epi64((__m128i*)&out[i], res);
667 }
668 if (i != num_pixels) {
669 VP8LPredictorsSub_C[13](in + i, upper + i, num_pixels - i, out + i);
670 }
671 }
672
673 //------------------------------------------------------------------------------
674 // Entry point
675
676 extern void VP8LEncDspInitSSE2(void);
677
VP8LEncDspInitSSE2(void)678 WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInitSSE2(void) {
679 VP8LSubtractGreenFromBlueAndRed = SubtractGreenFromBlueAndRed_SSE2;
680 VP8LTransformColor = TransformColor_SSE2;
681 VP8LCollectColorBlueTransforms = CollectColorBlueTransforms_SSE2;
682 VP8LCollectColorRedTransforms = CollectColorRedTransforms_SSE2;
683 VP8LAddVector = AddVector_SSE2;
684 VP8LAddVectorEq = AddVectorEq_SSE2;
685 #if !defined(DONT_USE_COMBINED_SHANNON_ENTROPY_SSE2_FUNC)
686 VP8LCombinedShannonEntropy = CombinedShannonEntropy_SSE2;
687 #endif
688 VP8LVectorMismatch = VectorMismatch_SSE2;
689 VP8LBundleColorMap = BundleColorMap_SSE2;
690
691 VP8LPredictorsSub[0] = PredictorSub0_SSE2;
692 VP8LPredictorsSub[1] = PredictorSub1_SSE2;
693 VP8LPredictorsSub[2] = PredictorSub2_SSE2;
694 VP8LPredictorsSub[3] = PredictorSub3_SSE2;
695 VP8LPredictorsSub[4] = PredictorSub4_SSE2;
696 VP8LPredictorsSub[5] = PredictorSub5_SSE2;
697 VP8LPredictorsSub[6] = PredictorSub6_SSE2;
698 VP8LPredictorsSub[7] = PredictorSub7_SSE2;
699 VP8LPredictorsSub[8] = PredictorSub8_SSE2;
700 VP8LPredictorsSub[9] = PredictorSub9_SSE2;
701 VP8LPredictorsSub[10] = PredictorSub10_SSE2;
702 VP8LPredictorsSub[11] = PredictorSub11_SSE2;
703 VP8LPredictorsSub[12] = PredictorSub12_SSE2;
704 VP8LPredictorsSub[13] = PredictorSub13_SSE2;
705 VP8LPredictorsSub[14] = PredictorSub0_SSE2; // <- padding security sentinels
706 VP8LPredictorsSub[15] = PredictorSub0_SSE2;
707 }
708
709 #else // !WEBP_USE_SSE2
710
711 WEBP_DSP_INIT_STUB(VP8LEncDspInitSSE2)
712
713 #endif // WEBP_USE_SSE2
714