CoCalc -- lossless_enc

GitHub Repository: Tetragramm/opencv
Path: blob/master/3rdparty/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 <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

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

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

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

129
static void CollectColorRedTransforms_SSE2(const uint32_t* argb, int stride,
130
                                           int tile_width, int tile_height,
131
                                           int green_to_red, int histo[]) {
132
  const __m128i mults_g = MK_CST_16(0, CST_5b(green_to_red));
133
  const __m128i mask_g = _mm_set1_epi32(0x00ff00);  // green mask
134
  const __m128i mask = _mm_set1_epi32(0xff);
135

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

171
//------------------------------------------------------------------------------
172

173
#define LINE_SIZE 16    // 8 or 16
174
static void AddVector_SSE2(const uint32_t* a, const uint32_t* b, uint32_t* out,
175
                           int size) {
176
  int i;
177
  assert(size % LINE_SIZE == 0);
178
  for (i = 0; i < size; i += LINE_SIZE) {
179
    const __m128i a0 = _mm_loadu_si128((const __m128i*)&a[i +  0]);
180
    const __m128i a1 = _mm_loadu_si128((const __m128i*)&a[i +  4]);
181
#if (LINE_SIZE == 16)
182
    const __m128i a2 = _mm_loadu_si128((const __m128i*)&a[i +  8]);
183
    const __m128i a3 = _mm_loadu_si128((const __m128i*)&a[i + 12]);
184
#endif
185
    const __m128i b0 = _mm_loadu_si128((const __m128i*)&b[i +  0]);
186
    const __m128i b1 = _mm_loadu_si128((const __m128i*)&b[i +  4]);
187
#if (LINE_SIZE == 16)
188
    const __m128i b2 = _mm_loadu_si128((const __m128i*)&b[i +  8]);
189
    const __m128i b3 = _mm_loadu_si128((const __m128i*)&b[i + 12]);
190
#endif
191
    _mm_storeu_si128((__m128i*)&out[i +  0], _mm_add_epi32(a0, b0));
192
    _mm_storeu_si128((__m128i*)&out[i +  4], _mm_add_epi32(a1, b1));
193
#if (LINE_SIZE == 16)
194
    _mm_storeu_si128((__m128i*)&out[i +  8], _mm_add_epi32(a2, b2));
195
    _mm_storeu_si128((__m128i*)&out[i + 12], _mm_add_epi32(a3, b3));
196
#endif
197
  }
198
}
199

200
static void AddVectorEq_SSE2(const uint32_t* a, uint32_t* out, int size) {
201
  int i;
202
  assert(size % LINE_SIZE == 0);
203
  for (i = 0; i < size; i += LINE_SIZE) {
204
    const __m128i a0 = _mm_loadu_si128((const __m128i*)&a[i +  0]);
205
    const __m128i a1 = _mm_loadu_si128((const __m128i*)&a[i +  4]);
206
#if (LINE_SIZE == 16)
207
    const __m128i a2 = _mm_loadu_si128((const __m128i*)&a[i +  8]);
208
    const __m128i a3 = _mm_loadu_si128((const __m128i*)&a[i + 12]);
209
#endif
210
    const __m128i b0 = _mm_loadu_si128((const __m128i*)&out[i +  0]);
211
    const __m128i b1 = _mm_loadu_si128((const __m128i*)&out[i +  4]);
212
#if (LINE_SIZE == 16)
213
    const __m128i b2 = _mm_loadu_si128((const __m128i*)&out[i +  8]);
214
    const __m128i b3 = _mm_loadu_si128((const __m128i*)&out[i + 12]);
215
#endif
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
#if (LINE_SIZE == 16)
219
    _mm_storeu_si128((__m128i*)&out[i +  8], _mm_add_epi32(a2, b2));
220
    _mm_storeu_si128((__m128i*)&out[i + 12], _mm_add_epi32(a3, b3));
221
#endif
222
  }
223
}
224
#undef LINE_SIZE
225

226
// Note we are adding uint32_t's as *signed* int32's (using _mm_add_epi32). But
227
// that's ok since the histogram values are less than 1<<28 (max picture size).
228
static void HistogramAdd_SSE2(const VP8LHistogram* const a,
229
                              const VP8LHistogram* const b,
230
                              VP8LHistogram* const out) {
231
  int i;
232
  const int literal_size = VP8LHistogramNumCodes(a->palette_code_bits_);
233
  assert(a->palette_code_bits_ == b->palette_code_bits_);
234
  if (b != out) {
235
    AddVector_SSE2(a->literal_, b->literal_, out->literal_, NUM_LITERAL_CODES);
236
    AddVector_SSE2(a->red_, b->red_, out->red_, NUM_LITERAL_CODES);
237
    AddVector_SSE2(a->blue_, b->blue_, out->blue_, NUM_LITERAL_CODES);
238
    AddVector_SSE2(a->alpha_, b->alpha_, out->alpha_, NUM_LITERAL_CODES);
239
  } else {
240
    AddVectorEq_SSE2(a->literal_, out->literal_, NUM_LITERAL_CODES);
241
    AddVectorEq_SSE2(a->red_, out->red_, NUM_LITERAL_CODES);
242
    AddVectorEq_SSE2(a->blue_, out->blue_, NUM_LITERAL_CODES);
243
    AddVectorEq_SSE2(a->alpha_, out->alpha_, NUM_LITERAL_CODES);
244
  }
245
  for (i = NUM_LITERAL_CODES; i < literal_size; ++i) {
246
    out->literal_[i] = a->literal_[i] + b->literal_[i];
247
  }
248
  for (i = 0; i < NUM_DISTANCE_CODES; ++i) {
249
    out->distance_[i] = a->distance_[i] + b->distance_[i];
250
  }
251
}
252

253
//------------------------------------------------------------------------------
254
// Entropy
255

256
// Checks whether the X or Y contribution is worth computing and adding.
257
// Used in loop unrolling.
258
#define ANALYZE_X_OR_Y(x_or_y, j)                                           \
259
  do {                                                                      \
260
    if ((x_or_y)[i + (j)] != 0) retval -= VP8LFastSLog2((x_or_y)[i + (j)]); \
261
  } while (0)
262

263
// Checks whether the X + Y contribution is worth computing and adding.
264
// Used in loop unrolling.
265
#define ANALYZE_XY(j)                  \
266
  do {                                 \
267
    if (tmp[j] != 0) {                 \
268
      retval -= VP8LFastSLog2(tmp[j]); \
269
      ANALYZE_X_OR_Y(X, j);            \
270
    }                                  \
271
  } while (0)
272

273
static float CombinedShannonEntropy_SSE2(const int X[256], const int Y[256]) {
274
  int i;
275
  double retval = 0.;
276
  int sumX, sumXY;
277
  int32_t tmp[4];
278
  __m128i zero = _mm_setzero_si128();
279
  // Sums up X + Y, 4 ints at a time (and will merge it at the end for sumXY).
280
  __m128i sumXY_128 = zero;
281
  __m128i sumX_128 = zero;
282

283
  for (i = 0; i < 256; i += 4) {
284
    const __m128i x = _mm_loadu_si128((const __m128i*)(X + i));
285
    const __m128i y = _mm_loadu_si128((const __m128i*)(Y + i));
286

287
    // Check if any X is non-zero: this actually provides a speedup as X is
288
    // usually sparse.
289
    if (_mm_movemask_epi8(_mm_cmpeq_epi32(x, zero)) != 0xFFFF) {
290
      const __m128i xy_128 = _mm_add_epi32(x, y);
291
      sumXY_128 = _mm_add_epi32(sumXY_128, xy_128);
292

293
      sumX_128 = _mm_add_epi32(sumX_128, x);
294

295
      // Analyze the different X + Y.
296
      _mm_storeu_si128((__m128i*)tmp, xy_128);
297

298
      ANALYZE_XY(0);
299
      ANALYZE_XY(1);
300
      ANALYZE_XY(2);
301
      ANALYZE_XY(3);
302
    } else {
303
      // X is fully 0, so only deal with Y.
304
      sumXY_128 = _mm_add_epi32(sumXY_128, y);
305

306
      ANALYZE_X_OR_Y(Y, 0);
307
      ANALYZE_X_OR_Y(Y, 1);
308
      ANALYZE_X_OR_Y(Y, 2);
309
      ANALYZE_X_OR_Y(Y, 3);
310
    }
311
  }
312

313
  // Sum up sumX_128 to get sumX.
314
  _mm_storeu_si128((__m128i*)tmp, sumX_128);
315
  sumX = tmp[3] + tmp[2] + tmp[1] + tmp[0];
316

317
  // Sum up sumXY_128 to get sumXY.
318
  _mm_storeu_si128((__m128i*)tmp, sumXY_128);
319
  sumXY = tmp[3] + tmp[2] + tmp[1] + tmp[0];
320

321
  retval += VP8LFastSLog2(sumX) + VP8LFastSLog2(sumXY);
322
  return (float)retval;
323
}
324
#undef ANALYZE_X_OR_Y
325
#undef ANALYZE_XY
326

327
//------------------------------------------------------------------------------
328

329
static int VectorMismatch_SSE2(const uint32_t* const array1,
330
                               const uint32_t* const array2, int length) {
331
  int match_len;
332

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

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

373
  while (match_len < length && array1[match_len] == array2[match_len]) {
374
    ++match_len;
375
  }
376
  return match_len;
377
}
378

379
// Bundles multiple (1, 2, 4 or 8) pixels into a single pixel.
380
static void BundleColorMap_SSE2(const uint8_t* const row, int width, int xbits,
381
                                uint32_t* 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(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(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(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

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.
469
static void PredictorSub0_SSE2(const uint32_t* in, const uint32_t* upper,
470
                               int num_pixels, uint32_t* out) {
471
  int i;
472
  const __m128i black = _mm_set1_epi32(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, upper + i, num_pixels - i, out + i);
480
  }
481
}
482

483
#define GENERATE_PREDICTOR_1(X, IN)                                           \
484
static void PredictorSub##X##_SSE2(const uint32_t* in, const uint32_t* upper, \
485
                                   int num_pixels, uint32_t* out) {           \
486
  int i;                                                                      \
487
  for (i = 0; i + 4 <= num_pixels; i += 4) {                                  \
488
    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);              \
489
    const __m128i pred = _mm_loadu_si128((const __m128i*)&(IN));              \
490
    const __m128i res = _mm_sub_epi8(src, pred);                              \
491
    _mm_storeu_si128((__m128i*)&out[i], res);                                 \
492
  }                                                                           \
493
  if (i != num_pixels) {                                                      \
494
    VP8LPredictorsSub_C[(X)](in + i, upper + i, num_pixels - i, out + i);     \
495
  }                                                                           \
496
}
497

498
GENERATE_PREDICTOR_1(1, in[i - 1])       // Predictor1: L
499
GENERATE_PREDICTOR_1(2, upper[i])        // Predictor2: T
500
GENERATE_PREDICTOR_1(3, upper[i + 1])    // Predictor3: TR
501
GENERATE_PREDICTOR_1(4, upper[i - 1])    // Predictor4: TL
502
#undef GENERATE_PREDICTOR_1
503

504
// Predictor5: avg2(avg2(L, TR), T)
505
static void PredictorSub5_SSE2(const uint32_t* in, const uint32_t* upper,
506
                               int num_pixels, uint32_t* out) {
507
  int i;
508
  for (i = 0; i + 4 <= num_pixels; i += 4) {
509
    const __m128i L = _mm_loadu_si128((const __m128i*)&in[i - 1]);
510
    const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
511
    const __m128i TR = _mm_loadu_si128((const __m128i*)&upper[i + 1]);
512
    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
513
    __m128i avg, pred, res;
514
    Average2_m128i(&L, &TR, &avg);
515
    Average2_m128i(&avg, &T, &pred);
516
    res = _mm_sub_epi8(src, pred);
517
    _mm_storeu_si128((__m128i*)&out[i], res);
518
  }
519
  if (i != num_pixels) {
520
    VP8LPredictorsSub_C[5](in + i, upper + i, num_pixels - i, out + i);
521
  }
522
}
523

524
#define GENERATE_PREDICTOR_2(X, A, B)                                         \
525
static void PredictorSub##X##_SSE2(const uint32_t* in, const uint32_t* upper, \
526
                                   int num_pixels, uint32_t* out) {           \
527
  int i;                                                                      \
528
  for (i = 0; i + 4 <= num_pixels; i += 4) {                                  \
529
    const __m128i tA = _mm_loadu_si128((const __m128i*)&(A));                 \
530
    const __m128i tB = _mm_loadu_si128((const __m128i*)&(B));                 \
531
    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);              \
532
    __m128i pred, res;                                                        \
533
    Average2_m128i(&tA, &tB, &pred);                                          \
534
    res = _mm_sub_epi8(src, pred);                                            \
535
    _mm_storeu_si128((__m128i*)&out[i], res);                                 \
536
  }                                                                           \
537
  if (i != num_pixels) {                                                      \
538
    VP8LPredictorsSub_C[(X)](in + i, upper + i, num_pixels - i, out + i);     \
539
  }                                                                           \
540
}
541

542
GENERATE_PREDICTOR_2(6, in[i - 1], upper[i - 1])   // Predictor6: avg(L, TL)
543
GENERATE_PREDICTOR_2(7, in[i - 1], upper[i])       // Predictor7: avg(L, T)
544
GENERATE_PREDICTOR_2(8, upper[i - 1], upper[i])    // Predictor8: avg(TL, T)
545
GENERATE_PREDICTOR_2(9, upper[i], upper[i + 1])    // Predictor9: average(T, TR)
546
#undef GENERATE_PREDICTOR_2
547

548
// Predictor10: avg(avg(L,TL), avg(T, TR)).
549
static void PredictorSub10_SSE2(const uint32_t* in, const uint32_t* upper,
550
                                int num_pixels, uint32_t* out) {
551
  int i;
552
  for (i = 0; i + 4 <= num_pixels; i += 4) {
553
    const __m128i L = _mm_loadu_si128((const __m128i*)&in[i - 1]);
554
    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
555
    const __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);
556
    const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
557
    const __m128i TR = _mm_loadu_si128((const __m128i*)&upper[i + 1]);
558
    __m128i avgTTR, avgLTL, avg, res;
559
    Average2_m128i(&T, &TR, &avgTTR);
560
    Average2_m128i(&L, &TL, &avgLTL);
561
    Average2_m128i(&avgTTR, &avgLTL, &avg);
562
    res = _mm_sub_epi8(src, avg);
563
    _mm_storeu_si128((__m128i*)&out[i], res);
564
  }
565
  if (i != num_pixels) {
566
    VP8LPredictorsSub_C[10](in + i, upper + i, num_pixels - i, out + i);
567
  }
568
}
569

570
// Predictor11: select.
571
static void GetSumAbsDiff32_SSE2(const __m128i* const A, const __m128i* const B,
572
                                 __m128i* const out) {
573
  // We can unpack with any value on the upper 32 bits, provided it's the same
574
  // on both operands (to that their sum of abs diff is zero). Here we use *A.
575
  const __m128i A_lo = _mm_unpacklo_epi32(*A, *A);
576
  const __m128i B_lo = _mm_unpacklo_epi32(*B, *A);
577
  const __m128i A_hi = _mm_unpackhi_epi32(*A, *A);
578
  const __m128i B_hi = _mm_unpackhi_epi32(*B, *A);
579
  const __m128i s_lo = _mm_sad_epu8(A_lo, B_lo);
580
  const __m128i s_hi = _mm_sad_epu8(A_hi, B_hi);
581
  *out = _mm_packs_epi32(s_lo, s_hi);
582
}
583

584
static void PredictorSub11_SSE2(const uint32_t* in, const uint32_t* upper,
585
                                int num_pixels, uint32_t* out) {
586
  int i;
587
  for (i = 0; i + 4 <= num_pixels; i += 4) {
588
    const __m128i L = _mm_loadu_si128((const __m128i*)&in[i - 1]);
589
    const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
590
    const __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);
591
    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
592
    __m128i pa, pb;
593
    GetSumAbsDiff32_SSE2(&T, &TL, &pa);   // pa = sum |T-TL|
594
    GetSumAbsDiff32_SSE2(&L, &TL, &pb);   // pb = sum |L-TL|
595
    {
596
      const __m128i mask = _mm_cmpgt_epi32(pb, pa);
597
      const __m128i A = _mm_and_si128(mask, L);
598
      const __m128i B = _mm_andnot_si128(mask, T);
599
      const __m128i pred = _mm_or_si128(A, B);    // pred = (L > T)? L : T
600
      const __m128i res = _mm_sub_epi8(src, pred);
601
      _mm_storeu_si128((__m128i*)&out[i], res);
602
    }
603
  }
604
  if (i != num_pixels) {
605
    VP8LPredictorsSub_C[11](in + i, upper + i, num_pixels - i, out + i);
606
  }
607
}
608

609
// Predictor12: ClampedSubSubtractFull.
610
static void PredictorSub12_SSE2(const uint32_t* in, const uint32_t* upper,
611
                                int num_pixels, uint32_t* out) {
612
  int i;
613
  const __m128i zero = _mm_setzero_si128();
614
  for (i = 0; i + 4 <= num_pixels; i += 4) {
615
    const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);
616
    const __m128i L = _mm_loadu_si128((const __m128i*)&in[i - 1]);
617
    const __m128i L_lo = _mm_unpacklo_epi8(L, zero);
618
    const __m128i L_hi = _mm_unpackhi_epi8(L, zero);
619
    const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);
620
    const __m128i T_lo = _mm_unpacklo_epi8(T, zero);
621
    const __m128i T_hi = _mm_unpackhi_epi8(T, zero);
622
    const __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);
623
    const __m128i TL_lo = _mm_unpacklo_epi8(TL, zero);
624
    const __m128i TL_hi = _mm_unpackhi_epi8(TL, zero);
625
    const __m128i diff_lo = _mm_sub_epi16(T_lo, TL_lo);
626
    const __m128i diff_hi = _mm_sub_epi16(T_hi, TL_hi);
627
    const __m128i pred_lo = _mm_add_epi16(L_lo, diff_lo);
628
    const __m128i pred_hi = _mm_add_epi16(L_hi, diff_hi);
629
    const __m128i pred = _mm_packus_epi16(pred_lo, pred_hi);
630
    const __m128i res = _mm_sub_epi8(src, pred);
631
    _mm_storeu_si128((__m128i*)&out[i], res);
632
  }
633
  if (i != num_pixels) {
634
    VP8LPredictorsSub_C[12](in + i, upper + i, num_pixels - i, out + i);
635
  }
636
}
637

638
// Predictors13: ClampedAddSubtractHalf
639
static void PredictorSub13_SSE2(const uint32_t* in, const uint32_t* upper,
640
                                int num_pixels, uint32_t* out) {
641
  int i;
642
  const __m128i zero = _mm_setzero_si128();
643
  for (i = 0; i + 2 <= num_pixels; i += 2) {
644
    // we can only process two pixels at a time
645
    const __m128i L = _mm_loadl_epi64((const __m128i*)&in[i - 1]);
646
    const __m128i src = _mm_loadl_epi64((const __m128i*)&in[i]);
647
    const __m128i T = _mm_loadl_epi64((const __m128i*)&upper[i]);
648
    const __m128i TL = _mm_loadl_epi64((const __m128i*)&upper[i - 1]);
649
    const __m128i L_lo = _mm_unpacklo_epi8(L, zero);
650
    const __m128i T_lo = _mm_unpacklo_epi8(T, zero);
651
    const __m128i TL_lo = _mm_unpacklo_epi8(TL, zero);
652
    const __m128i sum = _mm_add_epi16(T_lo, L_lo);
653
    const __m128i avg = _mm_srli_epi16(sum, 1);
654
    const __m128i A1 = _mm_sub_epi16(avg, TL_lo);
655
    const __m128i bit_fix = _mm_cmpgt_epi16(TL_lo, avg);
656
    const __m128i A2 = _mm_sub_epi16(A1, bit_fix);
657
    const __m128i A3 = _mm_srai_epi16(A2, 1);
658
    const __m128i A4 = _mm_add_epi16(avg, A3);
659
    const __m128i pred = _mm_packus_epi16(A4, A4);
660
    const __m128i res = _mm_sub_epi8(src, pred);
661
    _mm_storel_epi64((__m128i*)&out[i], res);
662
  }
663
  if (i != num_pixels) {
664
    VP8LPredictorsSub_C[13](in + i, upper + i, num_pixels - i, out + i);
665
  }
666
}
667

668
//------------------------------------------------------------------------------
669
// Entry point
670

671
extern void VP8LEncDspInitSSE2(void);
672

673
WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInitSSE2(void) {
674
  VP8LSubtractGreenFromBlueAndRed = SubtractGreenFromBlueAndRed_SSE2;
675
  VP8LTransformColor = TransformColor_SSE2;
676
  VP8LCollectColorBlueTransforms = CollectColorBlueTransforms_SSE2;
677
  VP8LCollectColorRedTransforms = CollectColorRedTransforms_SSE2;
678
  VP8LHistogramAdd = HistogramAdd_SSE2;
679
  VP8LCombinedShannonEntropy = CombinedShannonEntropy_SSE2;
680
  VP8LVectorMismatch = VectorMismatch_SSE2;
681
  VP8LBundleColorMap = BundleColorMap_SSE2;
682

683
  VP8LPredictorsSub[0] = PredictorSub0_SSE2;
684
  VP8LPredictorsSub[1] = PredictorSub1_SSE2;
685
  VP8LPredictorsSub[2] = PredictorSub2_SSE2;
686
  VP8LPredictorsSub[3] = PredictorSub3_SSE2;
687
  VP8LPredictorsSub[4] = PredictorSub4_SSE2;
688
  VP8LPredictorsSub[5] = PredictorSub5_SSE2;
689
  VP8LPredictorsSub[6] = PredictorSub6_SSE2;
690
  VP8LPredictorsSub[7] = PredictorSub7_SSE2;
691
  VP8LPredictorsSub[8] = PredictorSub8_SSE2;
692
  VP8LPredictorsSub[9] = PredictorSub9_SSE2;
693
  VP8LPredictorsSub[10] = PredictorSub10_SSE2;
694
  VP8LPredictorsSub[11] = PredictorSub11_SSE2;
695
  VP8LPredictorsSub[12] = PredictorSub12_SSE2;
696
  VP8LPredictorsSub[13] = PredictorSub13_SSE2;
697
  VP8LPredictorsSub[14] = PredictorSub0_SSE2;  // <- padding security sentinels
698
  VP8LPredictorsSub[15] = PredictorSub0_SSE2;
699
}
700

701
#else  // !WEBP_USE_SSE2
702

703
WEBP_DSP_INIT_STUB(VP8LEncDspInitSSE2)
704

705
#endif  // WEBP_USE_SSE2
706

707
Product

Resources

Company
