CoCalc -- lossless_enc

GitHub Repository: godotengine/godot
Path: blob/master/thirdparty/libwebp/src/dsp/lossless_enc_sse2.c
²²²⁰⁵ views
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 ([email protected])
13

14
#include "src/dsp/dsp.h"
15

16
#if defined(WEBP_USE_SSE2)
17
#include <emmintrin.h>
18

19
#include <assert.h>
20
#include <string.h>
21

22
#include "src/dsp/cpu.h"
23
#include "src/dsp/lossless.h"
24
#include "src/dsp/lossless_common.h"
25
#include "src/utils/utils.h"
26
#include "src/webp/format_constants.h"
27
#include "src/webp/types.h"
28

29
// For sign-extended multiplying constants, pre-shifted by 5:
30
#define CST_5b(X)  (((int16_t)((uint16_t)(X) << 8)) >> 5)
31

32
//------------------------------------------------------------------------------
33
// Subtract-Green Transform
34

35
static void SubtractGreenFromBlueAndRed_SSE2(uint32_t* argb_data,
36
                                             int num_pixels) {
37
  int i;
38
  for (i = 0; i + 4 <= num_pixels; i += 4) {
39
    const __m128i in = _mm_loadu_si128((__m128i*)&argb_data[i]); // argb
40
    const __m128i A = _mm_srli_epi16(in, 8);     // 0 a 0 g
41
    const __m128i B = _mm_shufflelo_epi16(A, _MM_SHUFFLE(2, 2, 0, 0));
42
    const __m128i C = _mm_shufflehi_epi16(B, _MM_SHUFFLE(2, 2, 0, 0));  // 0g0g
43
    const __m128i out = _mm_sub_epi8(in, C);
44
    _mm_storeu_si128((__m128i*)&argb_data[i], out);
45
  }
46
  // fallthrough and finish off with plain-C
47
  if (i != num_pixels) {
48
    VP8LSubtractGreenFromBlueAndRed_C(argb_data + i, num_pixels - i);
49
  }
50
}
51

52
//------------------------------------------------------------------------------
53
// Color Transform
54

55
#define MK_CST_16(HI, LO) \
56
  _mm_set1_epi32((int)(((uint32_t)(HI) << 16) | ((LO) & 0xffff)))
57

58
static void TransformColor_SSE2(const VP8LMultipliers* WEBP_RESTRICT const m,
59
                                uint32_t* WEBP_RESTRICT argb_data,
60
                                int num_pixels) {
61
  const __m128i mults_rb = MK_CST_16(CST_5b(m->green_to_red),
62
                                     CST_5b(m->green_to_blue));
63
  const __m128i mults_b2 = MK_CST_16(CST_5b(m->red_to_blue), 0);
64
  const __m128i mask_ag = _mm_set1_epi32((int)0xff00ff00);  // alpha-green masks
65
  const __m128i mask_rb = _mm_set1_epi32(0x00ff00ff);       // red-blue masks
66
  int i;
67
  for (i = 0; i + 4 <= num_pixels; i += 4) {
68
    const __m128i in = _mm_loadu_si128((__m128i*)&argb_data[i]); // argb
69
    const __m128i A = _mm_and_si128(in, mask_ag);     // a   0   g   0
70
    const __m128i B = _mm_shufflelo_epi16(A, _MM_SHUFFLE(2, 2, 0, 0));
71
    const __m128i C = _mm_shufflehi_epi16(B, _MM_SHUFFLE(2, 2, 0, 0));  // g0g0
72
    const __m128i D = _mm_mulhi_epi16(C, mults_rb);    // x dr  x db1
73
    const __m128i E = _mm_slli_epi16(in, 8);           // r 0   b   0
74
    const __m128i F = _mm_mulhi_epi16(E, mults_b2);    // x db2 0   0
75
    const __m128i G = _mm_srli_epi32(F, 16);           // 0 0   x db2
76
    const __m128i H = _mm_add_epi8(G, D);              // x dr  x  db
77
    const __m128i I = _mm_and_si128(H, mask_rb);       // 0 dr  0  db
78
    const __m128i out = _mm_sub_epi8(in, I);
79
    _mm_storeu_si128((__m128i*)&argb_data[i], out);
80
  }
81
  // fallthrough and finish off with plain-C
82
  if (i != num_pixels) {
83
    VP8LTransformColor_C(m, argb_data + i, num_pixels - i);
84
  }
85
}
86

87
//------------------------------------------------------------------------------
88
#define SPAN 8
89
static void CollectColorBlueTransforms_SSE2(const uint32_t* WEBP_RESTRICT argb,
90
                                            int stride,
91
                                            int tile_width, int tile_height,
92
                                            int green_to_blue, int red_to_blue,
93
                                            uint32_t histo[]) {
94
  const __m128i mults_r = MK_CST_16(CST_5b(red_to_blue), 0);
95
  const __m128i mults_g = MK_CST_16(0, CST_5b(green_to_blue));
96
  const __m128i mask_g = _mm_set1_epi32(0x00ff00);  // green mask
97
  const __m128i mask_b = _mm_set1_epi32(0x0000ff);  // blue mask
98
  int y;
99
  for (y = 0; y < tile_height; ++y) {
100
    const uint32_t* const src = argb + y * stride;
101
    int i, x;
102
    for (x = 0; x + SPAN <= tile_width; x += SPAN) {
103
      uint16_t values[SPAN];
104
      const __m128i in0 = _mm_loadu_si128((__m128i*)&src[x +        0]);
105
      const __m128i in1 = _mm_loadu_si128((__m128i*)&src[x + SPAN / 2]);
106
      const __m128i A0 = _mm_slli_epi16(in0, 8);        // r 0  | b 0
107
      const __m128i A1 = _mm_slli_epi16(in1, 8);
108
      const __m128i B0 = _mm_and_si128(in0, mask_g);    // 0 0  | g 0
109
      const __m128i B1 = _mm_and_si128(in1, mask_g);
110
      const __m128i C0 = _mm_mulhi_epi16(A0, mults_r);  // x db | 0 0
111
      const __m128i C1 = _mm_mulhi_epi16(A1, mults_r);
112
      const __m128i D0 = _mm_mulhi_epi16(B0, mults_g);  // 0 0  | x db
113
      const __m128i D1 = _mm_mulhi_epi16(B1, mults_g);
114
      const __m128i E0 = _mm_sub_epi8(in0, D0);         // x x  | x b'
115
      const __m128i E1 = _mm_sub_epi8(in1, D1);
116
      const __m128i F0 = _mm_srli_epi32(C0, 16);        // 0 0  | x db
117
      const __m128i F1 = _mm_srli_epi32(C1, 16);
118
      const __m128i G0 = _mm_sub_epi8(E0, F0);          // 0 0  | x b'
119
      const __m128i G1 = _mm_sub_epi8(E1, F1);
120
      const __m128i H0 = _mm_and_si128(G0, mask_b);     // 0 0  | 0 b
121
      const __m128i H1 = _mm_and_si128(G1, mask_b);
122
      const __m128i I = _mm_packs_epi32(H0, H1);        // 0 b' | 0 b'
123
      _mm_storeu_si128((__m128i*)values, I);
124
      for (i = 0; i < SPAN; ++i) ++histo[values[i]];
125
    }
126
  }
127
  {
128
    const int left_over = tile_width & (SPAN - 1);
129
    if (left_over > 0) {
130
      VP8LCollectColorBlueTransforms_C(argb + tile_width - left_over, stride,
131
                                       left_over, tile_height,
132
                                       green_to_blue, red_to_blue, histo);
133
    }
134
  }
135
}
136

137
static void CollectColorRedTransforms_SSE2(const uint32_t* WEBP_RESTRICT argb,
138
                                           int stride,
139
                                           int tile_width, int tile_height,
140
                                           int green_to_red, uint32_t histo[]) {
141
  const __m128i mults_g = MK_CST_16(0, CST_5b(green_to_red));
142
  const __m128i mask_g = _mm_set1_epi32(0x00ff00);  // green mask
143
  const __m128i mask = _mm_set1_epi32(0xff);
144

145
  int y;
146
  for (y = 0; y < tile_height; ++y) {
147
    const uint32_t* const src = argb + y * stride;
148
    int i, x;
149
    for (x = 0; x + SPAN <= tile_width; x += SPAN) {
150
      uint16_t values[SPAN];
151
      const __m128i in0 = _mm_loadu_si128((__m128i*)&src[x +        0]);
152
      const __m128i in1 = _mm_loadu_si128((__m128i*)&src[x + SPAN / 2]);
153
      const __m128i A0 = _mm_and_si128(in0, mask_g);    // 0 0  | g 0
154
      const __m128i A1 = _mm_and_si128(in1, mask_g);
155
      const __m128i B0 = _mm_srli_epi32(in0, 16);       // 0 0  | x r
156
      const __m128i B1 = _mm_srli_epi32(in1, 16);
157
      const __m128i C0 = _mm_mulhi_epi16(A0, mults_g);  // 0 0  | x dr
158
      const __m128i C1 = _mm_mulhi_epi16(A1, mults_g);
159
      const __m128i E0 = _mm_sub_epi8(B0, C0);          // x x  | x r'
160
      const __m128i E1 = _mm_sub_epi8(B1, C1);
161
      const __m128i F0 = _mm_and_si128(E0, mask);       // 0 0  | 0 r'
162
      const __m128i F1 = _mm_and_si128(E1, mask);
163
      const __m128i I = _mm_packs_epi32(F0, F1);
164
      _mm_storeu_si128((__m128i*)values, I);
165
      for (i = 0; i < SPAN; ++i) ++histo[values[i]];
166
    }
167
  }
168
  {
169
    const int left_over = tile_width & (SPAN - 1);
170
    if (left_over > 0) {
171
      VP8LCollectColorRedTransforms_C(argb + tile_width - left_over, stride,
172
                                      left_over, tile_height,
173
                                      green_to_red, histo);
174
    }
175
  }
176
}
177
#undef SPAN
178
#undef MK_CST_16
179

180
//------------------------------------------------------------------------------
181

182
// Note we are adding uint32_t's as *signed* int32's (using _mm_add_epi32). But
183
// that's ok since the histogram values are less than 1<<28 (max picture size).
184
static void AddVector_SSE2(const uint32_t* WEBP_RESTRICT a,
185
                           const uint32_t* WEBP_RESTRICT b,
186
                           uint32_t* WEBP_RESTRICT out, int size) {
187
  int i = 0;
188
  int aligned_size = size & ~15;
189
  // Size is, at minimum, NUM_DISTANCE_CODES (40) and may be as large as
190
  // NUM_LITERAL_CODES (256) + NUM_LENGTH_CODES (24) + (0 or a non-zero power of
191
  // 2). See the usage in VP8LHistogramAdd().
192
  assert(size >= 16);
193
  assert(size % 2 == 0);
194

195
  do {
196
    const __m128i a0 = _mm_loadu_si128((const __m128i*)&a[i +  0]);
197
    const __m128i a1 = _mm_loadu_si128((const __m128i*)&a[i +  4]);
198
    const __m128i a2 = _mm_loadu_si128((const __m128i*)&a[i +  8]);
199
    const __m128i a3 = _mm_loadu_si128((const __m128i*)&a[i + 12]);
200
    const __m128i b0 = _mm_loadu_si128((const __m128i*)&b[i +  0]);
201
    const __m128i b1 = _mm_loadu_si128((const __m128i*)&b[i +  4]);
202
    const __m128i b2 = _mm_loadu_si128((const __m128i*)&b[i +  8]);
203
    const __m128i b3 = _mm_loadu_si128((const __m128i*)&b[i + 12]);
204
    _mm_storeu_si128((__m128i*)&out[i +  0], _mm_add_epi32(a0, b0));
205
    _mm_storeu_si128((__m128i*)&out[i +  4], _mm_add_epi32(a1, b1));
206
    _mm_storeu_si128((__m128i*)&out[i +  8], _mm_add_epi32(a2, b2));
207
    _mm_storeu_si128((__m128i*)&out[i + 12], _mm_add_epi32(a3, b3));
208
    i += 16;
209
  } while (i != aligned_size);
210

211
  if ((size & 8) != 0) {
212
    const __m128i a0 = _mm_loadu_si128((const __m128i*)&a[i + 0]);
213
    const __m128i a1 = _mm_loadu_si128((const __m128i*)&a[i + 4]);
214
    const __m128i b0 = _mm_loadu_si128((const __m128i*)&b[i + 0]);
215
    const __m128i b1 = _mm_loadu_si128((const __m128i*)&b[i + 4]);
216
    _mm_storeu_si128((__m128i*)&out[i + 0], _mm_add_epi32(a0, b0));
217
    _mm_storeu_si128((__m128i*)&out[i + 4], _mm_add_epi32(a1, b1));
218
    i += 8;
219
  }
220

221
  size &= 7;
222
  if (size == 4) {
223
    const __m128i a0 = _mm_loadu_si128((const __m128i*)&a[i]);
224
    const __m128i b0 = _mm_loadu_si128((const __m128i*)&b[i]);
225
    _mm_storeu_si128((__m128i*)&out[i], _mm_add_epi32(a0, b0));
226
  } else if (size == 2) {
227
    const __m128i a0 = _mm_loadl_epi64((const __m128i*)&a[i]);
228
    const __m128i b0 = _mm_loadl_epi64((const __m128i*)&b[i]);
229
    _mm_storel_epi64((__m128i*)&out[i], _mm_add_epi32(a0, b0));
230
  }
231
}
232

233
static void AddVectorEq_SSE2(const uint32_t* WEBP_RESTRICT a,
234
                             uint32_t* WEBP_RESTRICT out, int size) {
235
  int i = 0;
236
  int aligned_size = size & ~15;
237
  // Size is, at minimum, NUM_DISTANCE_CODES (40) and may be as large as
238
  // NUM_LITERAL_CODES (256) + NUM_LENGTH_CODES (24) + (0 or a non-zero power of
239
  // 2). See the usage in VP8LHistogramAdd().
240
  assert(size >= 16);
241
  assert(size % 2 == 0);
242

243
  do {
244
    const __m128i a0 = _mm_loadu_si128((const __m128i*)&a[i +  0]);
245
    const __m128i a1 = _mm_loadu_si128((const __m128i*)&a[i +  4]);
246
    const __m128i a2 = _mm_loadu_si128((const __m128i*)&a[i +  8]);
247
    const __m128i a3 = _mm_loadu_si128((const __m128i*)&a[i + 12]);
248
    const __m128i b0 = _mm_loadu_si128((const __m128i*)&out[i +  0]);
249
    const __m128i b1 = _mm_loadu_si128((const __m128i*)&out[i +  4]);
250
    const __m128i b2 = _mm_loadu_si128((const __m128i*)&out[i +  8]);
251
    const __m128i b3 = _mm_loadu_si128((const __m128i*)&out[i + 12]);
252
    _mm_storeu_si128((__m128i*)&out[i +  0], _mm_add_epi32(a0, b0));
253
    _mm_storeu_si128((__m128i*)&out[i +  4], _mm_add_epi32(a1, b1));
254
    _mm_storeu_si128((__m128i*)&out[i +  8], _mm_add_epi32(a2, b2));
255
    _mm_storeu_si128((__m128i*)&out[i + 12], _mm_add_epi32(a3, b3));
256
    i += 16;
257
  } while (i != aligned_size);
258

259
  if ((size & 8) != 0) {
260
    const __m128i a0 = _mm_loadu_si128((const __m128i*)&a[i + 0]);
261
    const __m128i a1 = _mm_loadu_si128((const __m128i*)&a[i + 4]);
262
    const __m128i b0 = _mm_loadu_si128((const __m128i*)&out[i + 0]);
263
    const __m128i b1 = _mm_loadu_si128((const __m128i*)&out[i + 4]);
264
    _mm_storeu_si128((__m128i*)&out[i + 0], _mm_add_epi32(a0, b0));
265
    _mm_storeu_si128((__m128i*)&out[i + 4], _mm_add_epi32(a1, b1));
266
    i += 8;
267
  }
268

269
  size &= 7;
270
  if (size == 4) {
271
    const __m128i a0 = _mm_loadu_si128((const __m128i*)&a[i]);
272
    const __m128i b0 = _mm_loadu_si128((const __m128i*)&out[i]);
273
    _mm_storeu_si128((__m128i*)&out[i], _mm_add_epi32(a0, b0));
274
  } else if (size == 2) {
275
    const __m128i a0 = _mm_loadl_epi64((const __m128i*)&a[i]);
276
    const __m128i b0 = _mm_loadl_epi64((const __m128i*)&out[i]);
277
    _mm_storel_epi64((__m128i*)&out[i], _mm_add_epi32(a0, b0));
278
  }
279
}
280

281
//------------------------------------------------------------------------------
282
// Entropy
283

284
#if !defined(WEBP_HAVE_SLOW_CLZ_CTZ)
285

286
static uint64_t CombinedShannonEntropy_SSE2(const uint32_t X[256],
287
                                            const uint32_t Y[256]) {
288
  int i;
289
  uint64_t retval = 0;
290
  uint32_t sumX = 0, sumXY = 0;
291
  const __m128i zero = _mm_setzero_si128();
292

293
  for (i = 0; i < 256; i += 16) {
294
    const __m128i x0 = _mm_loadu_si128((const __m128i*)(X + i +  0));
295
    const __m128i y0 = _mm_loadu_si128((const __m128i*)(Y + i +  0));
296
    const __m128i x1 = _mm_loadu_si128((const __m128i*)(X + i +  4));
297
    const __m128i y1 = _mm_loadu_si128((const __m128i*)(Y + i +  4));
298
    const __m128i x2 = _mm_loadu_si128((const __m128i*)(X + i +  8));
299
    const __m128i y2 = _mm_loadu_si128((const __m128i*)(Y + i +  8));
300
    const __m128i x3 = _mm_loadu_si128((const __m128i*)(X + i + 12));
301
    const __m128i y3 = _mm_loadu_si128((const __m128i*)(Y + i + 12));
302
    const __m128i x4 = _mm_packs_epi16(_mm_packs_epi32(x0, x1),
303
                                       _mm_packs_epi32(x2, x3));
304
    const __m128i y4 = _mm_packs_epi16(_mm_packs_epi32(y0, y1),
305
                                       _mm_packs_epi32(y2, y3));
306
    const int32_t mx = _mm_movemask_epi8(_mm_cmpgt_epi8(x4, zero));
307
    int32_t my = _mm_movemask_epi8(_mm_cmpgt_epi8(y4, zero)) | mx;
308
    while (my) {
309
      const int32_t j = BitsCtz(my);
310
      uint32_t xy;
311
      if ((mx >> j) & 1) {
312
        const int x = X[i + j];
313
        sumXY += x;
314
        retval += VP8LFastSLog2(x);
315
      }
316
      xy = X[i + j] + Y[i + j];
317
      sumX += xy;
318
      retval += VP8LFastSLog2(xy);
319
      my &= my - 1;
320
    }
321
  }
322
  retval = VP8LFastSLog2(sumX) + VP8LFastSLog2(sumXY) - retval;
323
  return retval;
324
}
325

326
#else
327

328
#define DONT_USE_COMBINED_SHANNON_ENTROPY_SSE2_FUNC   // won't be faster
329

330
#endif
331

332
//------------------------------------------------------------------------------
333

334
static int VectorMismatch_SSE2(const uint32_t* const array1,
335
                               const uint32_t* const array2, int length) {
336
  int match_len;
337

338
  if (length >= 12) {
339
    __m128i A0 = _mm_loadu_si128((const __m128i*)&array1[0]);
340
    __m128i A1 = _mm_loadu_si128((const __m128i*)&array2[0]);
341
    match_len = 0;
342
    do {
343
      // Loop unrolling and early load both provide a speedup of 10% for the
344
      // current function. Also, max_limit can be MAX_LENGTH=4096 at most.
345
      const __m128i cmpA = _mm_cmpeq_epi32(A0, A1);
346
      const __m128i B0 =
347
          _mm_loadu_si128((const __m128i*)&array1[match_len + 4]);
348
      const __m128i B1 =
349
          _mm_loadu_si128((const __m128i*)&array2[match_len + 4]);
350
      if (_mm_movemask_epi8(cmpA) != 0xffff) break;
351
      match_len += 4;
352

353
      {
354
        const __m128i cmpB = _mm_cmpeq_epi32(B0, B1);
355
        A0 = _mm_loadu_si128((const __m128i*)&array1[match_len + 4]);
356
        A1 = _mm_loadu_si128((const __m128i*)&array2[match_len + 4]);
357
        if (_mm_movemask_epi8(cmpB) != 0xffff) break;
358
        match_len += 4;
359
      }
360
    } while (match_len + 12 < length);
361
  } else {
362
    match_len = 0;
363
    // Unroll the potential first two loops.
364
    if (length >= 4 &&
365
        _mm_movemask_epi8(_mm_cmpeq_epi32(
366
            _mm_loadu_si128((const __m128i*)&array1[0]),
367
            _mm_loadu_si128((const __m128i*)&array2[0]))) == 0xffff) {
368
      match_len = 4;
369
      if (length >= 8 &&
370
          _mm_movemask_epi8(_mm_cmpeq_epi32(
371
              _mm_loadu_si128((const __m128i*)&array1[4]),
372
              _mm_loadu_si128((const __m128i*)&array2[4]))) == 0xffff) {
373
        match_len = 8;
374
      }
375
    }
376
  }
377

378
  while (match_len < length && array1[match_len] == array2[match_len]) {
379
    ++match_len;
380
  }
381
  return match_len;
382
}
383

384
// Bundles multiple (1, 2, 4 or 8) pixels into a single pixel.
385
static void BundleColorMap_SSE2(const uint8_t* WEBP_RESTRICT const row,
386
                                int width, int xbits,
387
                                uint32_t* WEBP_RESTRICT dst) {
388
  int x;
389
  assert(xbits >= 0);
390
  assert(xbits <= 3);
391
  switch (xbits) {
392
    case 0: {
393
      const __m128i ff = _mm_set1_epi16((short)0xff00);
394
      const __m128i zero = _mm_setzero_si128();
395
      // Store 0xff000000 | (row[x] << 8).
396
      for (x = 0; x + 16 <= width; x += 16, dst += 16) {
397
        const __m128i in = _mm_loadu_si128((const __m128i*)&row[x]);
398
        const __m128i in_lo = _mm_unpacklo_epi8(zero, in);
399
        const __m128i dst0 = _mm_unpacklo_epi16(in_lo, ff);
400
        const __m128i dst1 = _mm_unpackhi_epi16(in_lo, ff);
401
        const __m128i in_hi = _mm_unpackhi_epi8(zero, in);
402
        const __m128i dst2 = _mm_unpacklo_epi16(in_hi, ff);
403
        const __m128i dst3 = _mm_unpackhi_epi16(in_hi, ff);
404
        _mm_storeu_si128((__m128i*)&dst[0], dst0);
405
        _mm_storeu_si128((__m128i*)&dst[4], dst1);
406
        _mm_storeu_si128((__m128i*)&dst[8], dst2);
407
        _mm_storeu_si128((__m128i*)&dst[12], dst3);
408
      }
409
      break;
410
    }
411
    case 1: {
412
      const __m128i ff = _mm_set1_epi16((short)0xff00);
413
      const __m128i mul = _mm_set1_epi16(0x110);
414
      for (x = 0; x + 16 <= width; x += 16, dst += 8) {
415
        // 0a0b | (where a/b are 4 bits).
416
        const __m128i in = _mm_loadu_si128((const __m128i*)&row[x]);
417
        const __m128i tmp = _mm_mullo_epi16(in, mul);  // aba0
418
        const __m128i pack = _mm_and_si128(tmp, ff);   // ab00
419
        const __m128i dst0 = _mm_unpacklo_epi16(pack, ff);
420
        const __m128i dst1 = _mm_unpackhi_epi16(pack, ff);
421
        _mm_storeu_si128((__m128i*)&dst[0], dst0);
422
        _mm_storeu_si128((__m128i*)&dst[4], dst1);
423
      }
424
      break;
425
    }
426
    case 2: {
427
      const __m128i mask_or = _mm_set1_epi32((int)0xff000000);
428
      const __m128i mul_cst = _mm_set1_epi16(0x0104);
429
      const __m128i mask_mul = _mm_set1_epi16(0x0f00);
430
      for (x = 0; x + 16 <= width; x += 16, dst += 4) {
431
        // 000a000b000c000d | (where a/b/c/d are 2 bits).
432
        const __m128i in = _mm_loadu_si128((const __m128i*)&row[x]);
433
        const __m128i mul = _mm_mullo_epi16(in, mul_cst);  // 00ab00b000cd00d0
434
        const __m128i tmp = _mm_and_si128(mul, mask_mul);  // 00ab000000cd0000
435
        const __m128i shift = _mm_srli_epi32(tmp, 12);     // 00000000ab000000
436
        const __m128i pack = _mm_or_si128(shift, tmp);     // 00000000abcd0000
437
        // Convert to 0xff00**00.
438
        const __m128i res = _mm_or_si128(pack, mask_or);
439
        _mm_storeu_si128((__m128i*)dst, res);
440
      }
441
      break;
442
    }
443
    default: {
444
      assert(xbits == 3);
445
      for (x = 0; x + 16 <= width; x += 16, dst += 2) {
446
        // 0000000a00000000b... | (where a/b are 1 bit).
447
        const __m128i in = _mm_loadu_si128((const __m128i*)&row[x]);
448
        const __m128i shift = _mm_slli_epi64(in, 7);
449
        const uint32_t move = _mm_movemask_epi8(shift);
450
        dst[0] = 0xff000000 | ((move & 0xff) << 8);
451
        dst[1] = 0xff000000 | (move & 0xff00);
452
      }
453
      break;
454
    }
455
  }
456
  if (x != width) {
457
    VP8LBundleColorMap_C(row + x, width - x, xbits, dst);
458
  }
459
}
460

461
//------------------------------------------------------------------------------
462
// Batch version of Predictor Transform subtraction
463

464
static WEBP_INLINE void Average2_m128i(const __m128i* const a0,
465
                                       const __m128i* const a1,
466
                                       __m128i* const avg) {
467
  // (a + b) >> 1 = ((a + b + 1) >> 1) - ((a ^ b) & 1)
468
  const __m128i ones = _mm_set1_epi8(1);
469
  const __m128i avg1 = _mm_avg_epu8(*a0, *a1);
470
  const __m128i one = _mm_and_si128(_mm_xor_si128(*a0, *a1), ones);
471
  *avg = _mm_sub_epi8(avg1, one);
472
}
473

474
// Predictor0: ARGB_BLACK.
475
static void PredictorSub0_SSE2(const uint32_t* in, const uint32_t* upper,
476
                               int num_pixels, uint32_t* WEBP_RESTRICT out) {
477
  int i;
478
  const __m128i black = _mm_set1_epi32((int)ARGB_BLACK);
479
  for (i = 0; i + 4 <= num_pixels; i += 4) {
480
    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
481
    const __m128i res = _mm_sub_epi8(src, black);
482
    _mm_storeu_si128((__m128i*)&out[i], res);
483
  }
484
  if (i != num_pixels) {
485
    VP8LPredictorsSub_C[0](in + i, NULL, num_pixels - i, out + i);
486
  }
487
  (void)upper;
488
}
489

490
#define GENERATE_PREDICTOR_1(X, IN)                                         \
491
  static void PredictorSub##X##_SSE2(const uint32_t* const in,              \
492
                                     const uint32_t* const upper,           \
493
                                     int num_pixels,                        \
494
                                     uint32_t* WEBP_RESTRICT const out) {   \
495
    int i;                                                                  \
496
    for (i = 0; i + 4 <= num_pixels; i += 4) {                              \
497
      const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);          \
498
      const __m128i pred = _mm_loadu_si128((const __m128i*)&(IN));          \
499
      const __m128i res = _mm_sub_epi8(src, pred);                          \
500
      _mm_storeu_si128((__m128i*)&out[i], res);                             \
501
    }                                                                       \
502
    if (i != num_pixels) {                                                  \
503
      VP8LPredictorsSub_C[(X)](in + i, WEBP_OFFSET_PTR(upper, i),           \
504
                               num_pixels - i, out + i);                    \
505
    }                                                                       \
506
  }
507

508
GENERATE_PREDICTOR_1(1, in[i - 1])       // Predictor1: L
509
GENERATE_PREDICTOR_1(2, upper[i])        // Predictor2: T
510
GENERATE_PREDICTOR_1(3, upper[i + 1])    // Predictor3: TR
511
GENERATE_PREDICTOR_1(4, upper[i - 1])    // Predictor4: TL
512
#undef GENERATE_PREDICTOR_1
513

514
// Predictor5: avg2(avg2(L, TR), T)
515
static void PredictorSub5_SSE2(const uint32_t* in, const uint32_t* upper,
516
                               int num_pixels, uint32_t* WEBP_RESTRICT out) {
517
  int i;
518
  for (i = 0; i + 4 <= num_pixels; i += 4) {
519
    const __m128i L = _mm_loadu_si128((const __m128i*)&in[i - 1]);
520
    const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
521
    const __m128i TR = _mm_loadu_si128((const __m128i*)&upper[i + 1]);
522
    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
523
    __m128i avg, pred, res;
524
    Average2_m128i(&L, &TR, &avg);
525
    Average2_m128i(&avg, &T, &pred);
526
    res = _mm_sub_epi8(src, pred);
527
    _mm_storeu_si128((__m128i*)&out[i], res);
528
  }
529
  if (i != num_pixels) {
530
    VP8LPredictorsSub_C[5](in + i, upper + i, num_pixels - i, out + i);
531
  }
532
}
533

534
#define GENERATE_PREDICTOR_2(X, A, B)                                         \
535
static void PredictorSub##X##_SSE2(const uint32_t* in, const uint32_t* upper, \
536
                                   int num_pixels,                            \
537
                                   uint32_t* WEBP_RESTRICT out) {             \
538
  int i;                                                                      \
539
  for (i = 0; i + 4 <= num_pixels; i += 4) {                                  \
540
    const __m128i tA = _mm_loadu_si128((const __m128i*)&(A));                 \
541
    const __m128i tB = _mm_loadu_si128((const __m128i*)&(B));                 \
542
    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);              \
543
    __m128i pred, res;                                                        \
544
    Average2_m128i(&tA, &tB, &pred);                                          \
545
    res = _mm_sub_epi8(src, pred);                                            \
546
    _mm_storeu_si128((__m128i*)&out[i], res);                                 \
547
  }                                                                           \
548
  if (i != num_pixels) {                                                      \
549
    VP8LPredictorsSub_C[(X)](in + i, upper + i, num_pixels - i, out + i);     \
550
  }                                                                           \
551
}
552

553
GENERATE_PREDICTOR_2(6, in[i - 1], upper[i - 1])   // Predictor6: avg(L, TL)
554
GENERATE_PREDICTOR_2(7, in[i - 1], upper[i])       // Predictor7: avg(L, T)
555
GENERATE_PREDICTOR_2(8, upper[i - 1], upper[i])    // Predictor8: avg(TL, T)
556
GENERATE_PREDICTOR_2(9, upper[i], upper[i + 1])    // Predictor9: average(T, TR)
557
#undef GENERATE_PREDICTOR_2
558

559
// Predictor10: avg(avg(L,TL), avg(T, TR)).
560
static void PredictorSub10_SSE2(const uint32_t* in, const uint32_t* upper,
561
                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
562
  int i;
563
  for (i = 0; i + 4 <= num_pixels; i += 4) {
564
    const __m128i L = _mm_loadu_si128((const __m128i*)&in[i - 1]);
565
    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
566
    const __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);
567
    const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
568
    const __m128i TR = _mm_loadu_si128((const __m128i*)&upper[i + 1]);
569
    __m128i avgTTR, avgLTL, avg, res;
570
    Average2_m128i(&T, &TR, &avgTTR);
571
    Average2_m128i(&L, &TL, &avgLTL);
572
    Average2_m128i(&avgTTR, &avgLTL, &avg);
573
    res = _mm_sub_epi8(src, avg);
574
    _mm_storeu_si128((__m128i*)&out[i], res);
575
  }
576
  if (i != num_pixels) {
577
    VP8LPredictorsSub_C[10](in + i, upper + i, num_pixels - i, out + i);
578
  }
579
}
580

581
// Predictor11: select.
582
static void GetSumAbsDiff32_SSE2(const __m128i* const A, const __m128i* const B,
583
                                 __m128i* const out) {
584
  // We can unpack with any value on the upper 32 bits, provided it's the same
585
  // on both operands (to that their sum of abs diff is zero). Here we use *A.
586
  const __m128i A_lo = _mm_unpacklo_epi32(*A, *A);
587
  const __m128i B_lo = _mm_unpacklo_epi32(*B, *A);
588
  const __m128i A_hi = _mm_unpackhi_epi32(*A, *A);
589
  const __m128i B_hi = _mm_unpackhi_epi32(*B, *A);
590
  const __m128i s_lo = _mm_sad_epu8(A_lo, B_lo);
591
  const __m128i s_hi = _mm_sad_epu8(A_hi, B_hi);
592
  *out = _mm_packs_epi32(s_lo, s_hi);
593
}
594

595
static void PredictorSub11_SSE2(const uint32_t* in, const uint32_t* upper,
596
                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
597
  int i;
598
  for (i = 0; i + 4 <= num_pixels; i += 4) {
599
    const __m128i L = _mm_loadu_si128((const __m128i*)&in[i - 1]);
600
    const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
601
    const __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);
602
    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
603
    __m128i pa, pb;
604
    GetSumAbsDiff32_SSE2(&T, &TL, &pa);   // pa = sum |T-TL|
605
    GetSumAbsDiff32_SSE2(&L, &TL, &pb);   // pb = sum |L-TL|
606
    {
607
      const __m128i mask = _mm_cmpgt_epi32(pb, pa);
608
      const __m128i A = _mm_and_si128(mask, L);
609
      const __m128i B = _mm_andnot_si128(mask, T);
610
      const __m128i pred = _mm_or_si128(A, B);    // pred = (L > T)? L : T
611
      const __m128i res = _mm_sub_epi8(src, pred);
612
      _mm_storeu_si128((__m128i*)&out[i], res);
613
    }
614
  }
615
  if (i != num_pixels) {
616
    VP8LPredictorsSub_C[11](in + i, upper + i, num_pixels - i, out + i);
617
  }
618
}
619

620
// Predictor12: ClampedSubSubtractFull.
621
static void PredictorSub12_SSE2(const uint32_t* in, const uint32_t* upper,
622
                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
623
  int i;
624
  const __m128i zero = _mm_setzero_si128();
625
  for (i = 0; i + 4 <= num_pixels; i += 4) {
626
    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
627
    const __m128i L = _mm_loadu_si128((const __m128i*)&in[i - 1]);
628
    const __m128i L_lo = _mm_unpacklo_epi8(L, zero);
629
    const __m128i L_hi = _mm_unpackhi_epi8(L, zero);
630
    const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
631
    const __m128i T_lo = _mm_unpacklo_epi8(T, zero);
632
    const __m128i T_hi = _mm_unpackhi_epi8(T, zero);
633
    const __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);
634
    const __m128i TL_lo = _mm_unpacklo_epi8(TL, zero);
635
    const __m128i TL_hi = _mm_unpackhi_epi8(TL, zero);
636
    const __m128i diff_lo = _mm_sub_epi16(T_lo, TL_lo);
637
    const __m128i diff_hi = _mm_sub_epi16(T_hi, TL_hi);
638
    const __m128i pred_lo = _mm_add_epi16(L_lo, diff_lo);
639
    const __m128i pred_hi = _mm_add_epi16(L_hi, diff_hi);
640
    const __m128i pred = _mm_packus_epi16(pred_lo, pred_hi);
641
    const __m128i res = _mm_sub_epi8(src, pred);
642
    _mm_storeu_si128((__m128i*)&out[i], res);
643
  }
644
  if (i != num_pixels) {
645
    VP8LPredictorsSub_C[12](in + i, upper + i, num_pixels - i, out + i);
646
  }
647
}
648

649
// Predictors13: ClampedAddSubtractHalf
650
static void PredictorSub13_SSE2(const uint32_t* in, const uint32_t* upper,
651
                                int num_pixels, uint32_t* WEBP_RESTRICT out) {
652
  int i;
653
  const __m128i zero = _mm_setzero_si128();
654
  for (i = 0; i + 4 <= num_pixels; i += 4) {
655
    const __m128i L = _mm_loadu_si128((const __m128i*)&in[i - 1]);
656
    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
657
    const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
658
    const __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);
659
    __m128i A4_lo, A4_hi;
660
    // lo.
661
    {
662
      const __m128i L_lo = _mm_unpacklo_epi8(L, zero);
663
      const __m128i T_lo = _mm_unpacklo_epi8(T, zero);
664
      const __m128i TL_lo = _mm_unpacklo_epi8(TL, zero);
665
      const __m128i sum_lo = _mm_add_epi16(T_lo, L_lo);
666
      const __m128i avg_lo = _mm_srli_epi16(sum_lo, 1);
667
      const __m128i A1_lo = _mm_sub_epi16(avg_lo, TL_lo);
668
      const __m128i bit_fix_lo = _mm_cmpgt_epi16(TL_lo, avg_lo);
669
      const __m128i A2_lo = _mm_sub_epi16(A1_lo, bit_fix_lo);
670
      const __m128i A3_lo = _mm_srai_epi16(A2_lo, 1);
671
      A4_lo = _mm_add_epi16(avg_lo, A3_lo);
672
    }
673
    // hi.
674
    {
675
      const __m128i L_hi = _mm_unpackhi_epi8(L, zero);
676
      const __m128i T_hi = _mm_unpackhi_epi8(T, zero);
677
      const __m128i TL_hi = _mm_unpackhi_epi8(TL, zero);
678
      const __m128i sum_hi = _mm_add_epi16(T_hi, L_hi);
679
      const __m128i avg_hi = _mm_srli_epi16(sum_hi, 1);
680
      const __m128i A1_hi = _mm_sub_epi16(avg_hi, TL_hi);
681
      const __m128i bit_fix_hi = _mm_cmpgt_epi16(TL_hi, avg_hi);
682
      const __m128i A2_hi = _mm_sub_epi16(A1_hi, bit_fix_hi);
683
      const __m128i A3_hi = _mm_srai_epi16(A2_hi, 1);
684
      A4_hi = _mm_add_epi16(avg_hi, A3_hi);
685
    }
686
    {
687
      const __m128i pred = _mm_packus_epi16(A4_lo, A4_hi);
688
      const __m128i res = _mm_sub_epi8(src, pred);
689
      _mm_storeu_si128((__m128i*)&out[i], res);
690
    }
691
  }
692
  if (i != num_pixels) {
693
    VP8LPredictorsSub_C[13](in + i, upper + i, num_pixels - i, out + i);
694
  }
695
}
696

697
//------------------------------------------------------------------------------
698
// Entry point
699

700
extern void VP8LEncDspInitSSE2(void);
701

702
WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInitSSE2(void) {
703
  VP8LSubtractGreenFromBlueAndRed = SubtractGreenFromBlueAndRed_SSE2;
704
  VP8LTransformColor = TransformColor_SSE2;
705
  VP8LCollectColorBlueTransforms = CollectColorBlueTransforms_SSE2;
706
  VP8LCollectColorRedTransforms = CollectColorRedTransforms_SSE2;
707
  VP8LAddVector = AddVector_SSE2;
708
  VP8LAddVectorEq = AddVectorEq_SSE2;
709
#if !defined(DONT_USE_COMBINED_SHANNON_ENTROPY_SSE2_FUNC)
710
  VP8LCombinedShannonEntropy = CombinedShannonEntropy_SSE2;
711
#endif
712
  VP8LVectorMismatch = VectorMismatch_SSE2;
713
  VP8LBundleColorMap = BundleColorMap_SSE2;
714

715
  VP8LPredictorsSub[0] = PredictorSub0_SSE2;
716
  VP8LPredictorsSub[1] = PredictorSub1_SSE2;
717
  VP8LPredictorsSub[2] = PredictorSub2_SSE2;
718
  VP8LPredictorsSub[3] = PredictorSub3_SSE2;
719
  VP8LPredictorsSub[4] = PredictorSub4_SSE2;
720
  VP8LPredictorsSub[5] = PredictorSub5_SSE2;
721
  VP8LPredictorsSub[6] = PredictorSub6_SSE2;
722
  VP8LPredictorsSub[7] = PredictorSub7_SSE2;
723
  VP8LPredictorsSub[8] = PredictorSub8_SSE2;
724
  VP8LPredictorsSub[9] = PredictorSub9_SSE2;
725
  VP8LPredictorsSub[10] = PredictorSub10_SSE2;
726
  VP8LPredictorsSub[11] = PredictorSub11_SSE2;
727
  VP8LPredictorsSub[12] = PredictorSub12_SSE2;
728
  VP8LPredictorsSub[13] = PredictorSub13_SSE2;
729
  VP8LPredictorsSub[14] = PredictorSub0_SSE2;  // <- padding security sentinels
730
  VP8LPredictorsSub[15] = PredictorSub0_SSE2;
731

732
  // SSE exports for AVX and above.
733
  VP8LSubtractGreenFromBlueAndRed_SSE = SubtractGreenFromBlueAndRed_SSE2;
734
  VP8LTransformColor_SSE = TransformColor_SSE2;
735
  VP8LCollectColorBlueTransforms_SSE = CollectColorBlueTransforms_SSE2;
736
  VP8LCollectColorRedTransforms_SSE = CollectColorRedTransforms_SSE2;
737
  VP8LBundleColorMap_SSE = BundleColorMap_SSE2;
738

739
  memcpy(VP8LPredictorsSub_SSE, VP8LPredictorsSub, sizeof(VP8LPredictorsSub));
740
}
741

742
#else  // !WEBP_USE_SSE2
743

744
WEBP_DSP_INIT_STUB(VP8LEncDspInitSSE2)
745

746
#endif  // WEBP_USE_SSE2
747

748
Product

Resources

Company
