// Copyright 2015 Google Inc. All Rights Reserved.

//

// Use of this source code is governed by a BSD-style license

// that can be found in the COPYING file in the root of the source

// tree. An additional intellectual property rights grant can be found

// in the file PATENTS. All contributing project authors may

// be found in the AUTHORS file in the root of the source tree.

// -----------------------------------------------------------------------------

//

// SSE2 variant of methods for lossless encoder

//

// Author: Skal (pascal.massimino@gmail.com)

#if defined(WEBP_USE_SSE2)

#include <assert.h>

#include <emmintrin.h>

#include "src/dsp/lossless.h"

#include "src/dsp/common_sse2.h"

#include "src/dsp/lossless_common.h"

// For sign-extended multiplying constants, pre-shifted by 5:

//------------------------------------------------------------------------------

// Subtract-Green Transform

static void SubtractGreenFromBlueAndRed_SSE2(uint32_t* argb_data,

int num_pixels) {

int i;

for (i = 0; i + 4 <= num_pixels; i += 4) {

const __m128i in = _mm_loadu_si128((__m128i*)&argb_data[i]); // argb

const __m128i A = _mm_srli_epi16(in, 8); // 0 a 0 g

const __m128i B = _mm_shufflelo_epi16(A, _MM_SHUFFLE(2, 2, 0, 0));

const __m128i C = _mm_shufflehi_epi16(B, _MM_SHUFFLE(2, 2, 0, 0)); // 0g0g

const __m128i out = _mm_sub_epi8(in, C);

_mm_storeu_si128((__m128i*)&argb_data[i], out);

}

// fallthrough and finish off with plain-C

if (i != num_pixels) {

VP8LSubtractGreenFromBlueAndRed_C(argb_data + i, num_pixels - i);

}

}

//------------------------------------------------------------------------------

// Color Transform

#define MK_CST_16(HI, LO) \

_mm_set1_epi32((int)(((uint32_t)(HI) << 16) | ((LO) & 0xffff)))

static void TransformColor_SSE2(const VP8LMultipliers* const m,

uint32_t* argb_data, int num_pixels) {

const __m128i mults_rb = MK_CST_16(CST_5b(m->green_to_red_),

CST_5b(m->green_to_blue_));

const __m128i mults_b2 = MK_CST_16(CST_5b(m->red_to_blue_), 0);

const __m128i mask_ag = _mm_set1_epi32(0xff00ff00); // alpha-green masks

const __m128i mask_rb = _mm_set1_epi32(0x00ff00ff); // red-blue masks

int i;

for (i = 0; i + 4 <= num_pixels; i += 4) {

const __m128i in = _mm_loadu_si128((__m128i*)&argb_data[i]); // argb

const __m128i A = _mm_and_si128(in, mask_ag); // a 0 g 0

const __m128i B = _mm_shufflelo_epi16(A, _MM_SHUFFLE(2, 2, 0, 0));

const __m128i C = _mm_shufflehi_epi16(B, _MM_SHUFFLE(2, 2, 0, 0)); // g0g0

const __m128i D = _mm_mulhi_epi16(C, mults_rb); // x dr x db1

const __m128i E = _mm_slli_epi16(in, 8); // r 0 b 0

const __m128i F = _mm_mulhi_epi16(E, mults_b2); // x db2 0 0

const __m128i G = _mm_srli_epi32(F, 16); // 0 0 x db2

const __m128i H = _mm_add_epi8(G, D); // x dr x db

const __m128i I = _mm_and_si128(H, mask_rb); // 0 dr 0 db

const __m128i out = _mm_sub_epi8(in, I);

_mm_storeu_si128((__m128i*)&argb_data[i], out);

}

// fallthrough and finish off with plain-C

if (i != num_pixels) {

VP8LTransformColor_C(m, argb_data + i, num_pixels - i);

}

}

//------------------------------------------------------------------------------

#define SPAN 8

static void CollectColorBlueTransforms_SSE2(const uint32_t* argb, int stride,

int tile_width, int tile_height,

int green_to_blue, int red_to_blue,

int histo[]) {

const __m128i mults_r = MK_CST_16(CST_5b(red_to_blue), 0);

const __m128i mults_g = MK_CST_16(0, CST_5b(green_to_blue));

const __m128i mask_g = _mm_set1_epi32(0x00ff00); // green mask

const __m128i mask_b = _mm_set1_epi32(0x0000ff); // blue mask

int y;

for (y = 0; y < tile_height; ++y) {

const uint32_t* const src = argb + y * stride;

int i, x;

for (x = 0; x + SPAN <= tile_width; x += SPAN) {

uint16_t values[SPAN];

const __m128i in0 = _mm_loadu_si128((__m128i*)&src[x + 0]);

const __m128i in1 = _mm_loadu_si128((__m128i*)&src[x + SPAN / 2]);

const __m128i A0 = _mm_slli_epi16(in0, 8); // r 0 | b 0

const __m128i A1 = _mm_slli_epi16(in1, 8);

const __m128i B0 = _mm_and_si128(in0, mask_g); // 0 0 | g 0

const __m128i B1 = _mm_and_si128(in1, mask_g);

const __m128i C0 = _mm_mulhi_epi16(A0, mults_r); // x db | 0 0

const __m128i C1 = _mm_mulhi_epi16(A1, mults_r);

const __m128i D0 = _mm_mulhi_epi16(B0, mults_g); // 0 0 | x db

const __m128i D1 = _mm_mulhi_epi16(B1, mults_g);

const __m128i E0 = _mm_sub_epi8(in0, D0); // x x | x b'

const __m128i E1 = _mm_sub_epi8(in1, D1);

const __m128i F0 = _mm_srli_epi32(C0, 16); // 0 0 | x db

const __m128i F1 = _mm_srli_epi32(C1, 16);

const __m128i G0 = _mm_sub_epi8(E0, F0); // 0 0 | x b'

const __m128i G1 = _mm_sub_epi8(E1, F1);

const __m128i H0 = _mm_and_si128(G0, mask_b); // 0 0 | 0 b

const __m128i H1 = _mm_and_si128(G1, mask_b);

const __m128i I = _mm_packs_epi32(H0, H1); // 0 b' | 0 b'

_mm_storeu_si128((__m128i*)values, I);

for (i = 0; i < SPAN; ++i) ++histo[values[i]];

}

}

{

const int left_over = tile_width & (SPAN - 1);

if (left_over > 0) {

VP8LCollectColorBlueTransforms_C(argb + tile_width - left_over, stride,

left_over, tile_height,

green_to_blue, red_to_blue, histo);

}

}

}

static void CollectColorRedTransforms_SSE2(const uint32_t* argb, int stride,

int tile_width, int tile_height,

int green_to_red, int histo[]) {

const __m128i mults_g = MK_CST_16(0, CST_5b(green_to_red));

const __m128i mask_g = _mm_set1_epi32(0x00ff00); // green mask

const __m128i mask = _mm_set1_epi32(0xff);

int y;

for (y = 0; y < tile_height; ++y) {

const uint32_t* const src = argb + y * stride;

int i, x;

for (x = 0; x + SPAN <= tile_width; x += SPAN) {

uint16_t values[SPAN];

const __m128i in0 = _mm_loadu_si128((__m128i*)&src[x + 0]);

const __m128i in1 = _mm_loadu_si128((__m128i*)&src[x + SPAN / 2]);

const __m128i A0 = _mm_and_si128(in0, mask_g); // 0 0 | g 0

const __m128i A1 = _mm_and_si128(in1, mask_g);

const __m128i B0 = _mm_srli_epi32(in0, 16); // 0 0 | x r

const __m128i B1 = _mm_srli_epi32(in1, 16);

const __m128i C0 = _mm_mulhi_epi16(A0, mults_g); // 0 0 | x dr

const __m128i C1 = _mm_mulhi_epi16(A1, mults_g);

const __m128i E0 = _mm_sub_epi8(B0, C0); // x x | x r'

const __m128i E1 = _mm_sub_epi8(B1, C1);

const __m128i F0 = _mm_and_si128(E0, mask); // 0 0 | 0 r'

const __m128i F1 = _mm_and_si128(E1, mask);

const __m128i I = _mm_packs_epi32(F0, F1);

_mm_storeu_si128((__m128i*)values, I);

for (i = 0; i < SPAN; ++i) ++histo[values[i]];

}

}

{

const int left_over = tile_width & (SPAN - 1);

if (left_over > 0) {

VP8LCollectColorRedTransforms_C(argb + tile_width - left_over, stride,

left_over, tile_height,

green_to_red, histo);

}

}

}

#undef SPAN

//------------------------------------------------------------------------------

#define LINE_SIZE 16 // 8 or 16

static void AddVector_SSE2(const uint32_t* a, const uint32_t* b, uint32_t* out,

int size) {

int i;

assert(size % LINE_SIZE == 0);

for (i = 0; i < size; i += LINE_SIZE) {

const __m128i a0 = _mm_loadu_si128((const __m128i*)&a[i + 0]);

const __m128i a1 = _mm_loadu_si128((const __m128i*)&a[i + 4]);

#if (LINE_SIZE == 16)

const __m128i a2 = _mm_loadu_si128((const __m128i*)&a[i + 8]);

const __m128i a3 = _mm_loadu_si128((const __m128i*)&a[i + 12]);

#endif

const __m128i b0 = _mm_loadu_si128((const __m128i*)&b[i + 0]);

const __m128i b1 = _mm_loadu_si128((const __m128i*)&b[i + 4]);

#if (LINE_SIZE == 16)

const __m128i b2 = _mm_loadu_si128((const __m128i*)&b[i + 8]);

const __m128i b3 = _mm_loadu_si128((const __m128i*)&b[i + 12]);

#endif

_mm_storeu_si128((__m128i*)&out[i + 0], _mm_add_epi32(a0, b0));

_mm_storeu_si128((__m128i*)&out[i + 4], _mm_add_epi32(a1, b1));

#if (LINE_SIZE == 16)

_mm_storeu_si128((__m128i*)&out[i + 8], _mm_add_epi32(a2, b2));

_mm_storeu_si128((__m128i*)&out[i + 12], _mm_add_epi32(a3, b3));

#endif

}

}

int i;

assert(size % LINE_SIZE == 0);

for (i = 0; i < size; i += LINE_SIZE) {

const __m128i a0 = _mm_loadu_si128((const __m128i*)&a[i + 0]);

const __m128i a1 = _mm_loadu_si128((const __m128i*)&a[i + 4]);

#if (LINE_SIZE == 16)

const __m128i a2 = _mm_loadu_si128((const __m128i*)&a[i + 8]);

const __m128i a3 = _mm_loadu_si128((const __m128i*)&a[i + 12]);

#endif

const __m128i b0 = _mm_loadu_si128((const __m128i*)&out[i + 0]);

const __m128i b1 = _mm_loadu_si128((const __m128i*)&out[i + 4]);

#if (LINE_SIZE == 16)

const __m128i b2 = _mm_loadu_si128((const __m128i*)&out[i + 8]);

const __m128i b3 = _mm_loadu_si128((const __m128i*)&out[i + 12]);

#endif

_mm_storeu_si128((__m128i*)&out[i + 0], _mm_add_epi32(a0, b0));

_mm_storeu_si128((__m128i*)&out[i + 4], _mm_add_epi32(a1, b1));

#if (LINE_SIZE == 16)

_mm_storeu_si128((__m128i*)&out[i + 8], _mm_add_epi32(a2, b2));

_mm_storeu_si128((__m128i*)&out[i + 12], _mm_add_epi32(a3, b3));

#endif

}

}

#undef LINE_SIZE

// Note we are adding uint32_t's as *signed* int32's (using _mm_add_epi32). But

// that's ok since the histogram values are less than 1<<28 (max picture size).

static void HistogramAdd_SSE2(const VP8LHistogram* const a,

const VP8LHistogram* const b,

VP8LHistogram* const out) {

int i;

const int literal_size = VP8LHistogramNumCodes(a->palette_code_bits_);

assert(a->palette_code_bits_ == b->palette_code_bits_);

if (b != out) {

AddVector_SSE2(a->literal_, b->literal_, out->literal_, NUM_LITERAL_CODES);

AddVector_SSE2(a->red_, b->red_, out->red_, NUM_LITERAL_CODES);

AddVector_SSE2(a->blue_, b->blue_, out->blue_, NUM_LITERAL_CODES);

AddVector_SSE2(a->alpha_, b->alpha_, out->alpha_, NUM_LITERAL_CODES);

AddVectorEq_SSE2(a->literal_, out->literal_, NUM_LITERAL_CODES);

AddVectorEq_SSE2(a->red_, out->red_, NUM_LITERAL_CODES);

AddVectorEq_SSE2(a->blue_, out->blue_, NUM_LITERAL_CODES);

AddVectorEq_SSE2(a->alpha_, out->alpha_, NUM_LITERAL_CODES);

}

for (i = NUM_LITERAL_CODES; i < literal_size; ++i) {

out->literal_[i] = a->literal_[i] + b->literal_[i];

}

for (i = 0; i < NUM_DISTANCE_CODES; ++i) {

out->distance_[i] = a->distance_[i] + b->distance_[i];

}

}

//------------------------------------------------------------------------------

// Entropy

// Checks whether the X or Y contribution is worth computing and adding.

// Used in loop unrolling.

#define ANALYZE_X_OR_Y(x_or_y, j) \

do { \

if ((x_or_y)[i + (j)] != 0) retval -= VP8LFastSLog2((x_or_y)[i + (j)]); \

} while (0)

// Checks whether the X + Y contribution is worth computing and adding.

// Used in loop unrolling.

#define ANALYZE_XY(j) \

do { \

if (tmp[j] != 0) { \

retval -= VP8LFastSLog2(tmp[j]); \

ANALYZE_X_OR_Y(X, j); \

} \

} while (0)

int i;

double retval = 0.;

int sumX, sumXY;

int32_t tmp[4];

__m128i zero = _mm_setzero_si128();

// Sums up X + Y, 4 ints at a time (and will merge it at the end for sumXY).

__m128i sumXY_128 = zero;

__m128i sumX_128 = zero;

for (i = 0; i < 256; i += 4) {

const __m128i x = _mm_loadu_si128((const __m128i*)(X + i));

const __m128i y = _mm_loadu_si128((const __m128i*)(Y + i));

// Check if any X is non-zero: this actually provides a speedup as X is

// usually sparse.

if (_mm_movemask_epi8(_mm_cmpeq_epi32(x, zero)) != 0xFFFF) {

const __m128i xy_128 = _mm_add_epi32(x, y);

sumXY_128 = _mm_add_epi32(sumXY_128, xy_128);

sumX_128 = _mm_add_epi32(sumX_128, x);

// Analyze the different X + Y.

_mm_storeu_si128((__m128i*)tmp, xy_128);

ANALYZE_XY(0);

ANALYZE_XY(1);

ANALYZE_XY(2);

ANALYZE_XY(3);

} else {

// X is fully 0, so only deal with Y.

sumXY_128 = _mm_add_epi32(sumXY_128, y);

ANALYZE_X_OR_Y(Y, 0);

ANALYZE_X_OR_Y(Y, 1);

ANALYZE_X_OR_Y(Y, 2);

ANALYZE_X_OR_Y(Y, 3);

}

}

// Sum up sumX_128 to get sumX.

_mm_storeu_si128((__m128i*)tmp, sumX_128);

sumX = tmp[3] + tmp[2] + tmp[1] + tmp[0];

// Sum up sumXY_128 to get sumXY.

_mm_storeu_si128((__m128i*)tmp, sumXY_128);

sumXY = tmp[3] + tmp[2] + tmp[1] + tmp[0];

retval += VP8LFastSLog2(sumX) + VP8LFastSLog2(sumXY);

return (float)retval;

}

#undef ANALYZE_X_OR_Y

#undef ANALYZE_XY

//------------------------------------------------------------------------------

static int VectorMismatch_SSE2(const uint32_t* const array1,

const uint32_t* const array2, int length) {

int match_len;

if (length >= 12) {

__m128i A0 = _mm_loadu_si128((const __m128i*)&array1[0]);

__m128i A1 = _mm_loadu_si128((const __m128i*)&array2[0]);

match_len = 0;

do {

// Loop unrolling and early load both provide a speedup of 10% for the

// current function. Also, max_limit can be MAX_LENGTH=4096 at most.

const __m128i cmpA = _mm_cmpeq_epi32(A0, A1);

const __m128i B0 =

_mm_loadu_si128((const __m128i*)&array1[match_len + 4]);

const __m128i B1 =

_mm_loadu_si128((const __m128i*)&array2[match_len + 4]);

if (_mm_movemask_epi8(cmpA) != 0xffff) break;

match_len += 4;

{

const __m128i cmpB = _mm_cmpeq_epi32(B0, B1);

A0 = _mm_loadu_si128((const __m128i*)&array1[match_len + 4]);

A1 = _mm_loadu_si128((const __m128i*)&array2[match_len + 4]);

if (_mm_movemask_epi8(cmpB) != 0xffff) break;

match_len += 4;

}

} while (match_len + 12 < length);

} else {

match_len = 0;

// Unroll the potential first two loops.

if (length >= 4 &&

_mm_movemask_epi8(_mm_cmpeq_epi32(

_mm_loadu_si128((const __m128i*)&array1[0]),

_mm_loadu_si128((const __m128i*)&array2[0]))) == 0xffff) {

match_len = 4;

if (length >= 8 &&

_mm_movemask_epi8(_mm_cmpeq_epi32(

_mm_loadu_si128((const __m128i*)&array1[4]),

_mm_loadu_si128((const __m128i*)&array2[4]))) == 0xffff) {

match_len = 8;

}

}

}

while (match_len < length && array1[match_len] == array2[match_len]) {

++match_len;

}

return match_len;

}

// Bundles multiple (1, 2, 4 or 8) pixels into a single pixel.

static void BundleColorMap_SSE2(const uint8_t* const row, int width, int xbits,

uint32_t* dst) {

int x;

assert(xbits >= 0);

assert(xbits <= 3);

switch (xbits) {

case 0: {

const __m128i ff = _mm_set1_epi16(0xff00);

const __m128i zero = _mm_setzero_si128();

// Store 0xff000000 | (row[x] << 8).

for (x = 0; x + 16 <= width; x += 16, dst += 16) {

const __m128i in = _mm_loadu_si128((const __m128i*)&row[x]);

const __m128i in_lo = _mm_unpacklo_epi8(zero, in);

const __m128i dst0 = _mm_unpacklo_epi16(in_lo, ff);

const __m128i dst1 = _mm_unpackhi_epi16(in_lo, ff);

const __m128i in_hi = _mm_unpackhi_epi8(zero, in);

const __m128i dst2 = _mm_unpacklo_epi16(in_hi, ff);

const __m128i dst3 = _mm_unpackhi_epi16(in_hi, ff);

_mm_storeu_si128((__m128i*)&dst[0], dst0);

_mm_storeu_si128((__m128i*)&dst[4], dst1);

_mm_storeu_si128((__m128i*)&dst[8], dst2);

_mm_storeu_si128((__m128i*)&dst[12], dst3);

}

break;

}

case 1: {

const __m128i ff = _mm_set1_epi16(0xff00);

const __m128i mul = _mm_set1_epi16(0x110);

for (x = 0; x + 16 <= width; x += 16, dst += 8) {

// 0a0b | (where a/b are 4 bits).

const __m128i in = _mm_loadu_si128((const __m128i*)&row[x]);

const __m128i tmp = _mm_mullo_epi16(in, mul); // aba0

const __m128i pack = _mm_and_si128(tmp, ff); // ab00

const __m128i dst0 = _mm_unpacklo_epi16(pack, ff);

const __m128i dst1 = _mm_unpackhi_epi16(pack, ff);

_mm_storeu_si128((__m128i*)&dst[0], dst0);

_mm_storeu_si128((__m128i*)&dst[4], dst1);

}

break;

}

case 2: {

const __m128i mask_or = _mm_set1_epi32(0xff000000);

const __m128i mul_cst = _mm_set1_epi16(0x0104);

const __m128i mask_mul = _mm_set1_epi16(0x0f00);

for (x = 0; x + 16 <= width; x += 16, dst += 4) {

// 000a000b000c000d | (where a/b/c/d are 2 bits).

const __m128i in = _mm_loadu_si128((const __m128i*)&row[x]);

const __m128i mul = _mm_mullo_epi16(in, mul_cst); // 00ab00b000cd00d0

const __m128i tmp = _mm_and_si128(mul, mask_mul); // 00ab000000cd0000

const __m128i shift = _mm_srli_epi32(tmp, 12); // 00000000ab000000

const __m128i pack = _mm_or_si128(shift, tmp); // 00000000abcd0000

// Convert to 0xff00**00.

const __m128i res = _mm_or_si128(pack, mask_or);

_mm_storeu_si128((__m128i*)dst, res);

}

break;

}

default: {

assert(xbits == 3);

for (x = 0; x + 16 <= width; x += 16, dst += 2) {

// 0000000a00000000b... | (where a/b are 1 bit).

const __m128i in = _mm_loadu_si128((const __m128i*)&row[x]);

const __m128i shift = _mm_slli_epi64(in, 7);

const uint32_t move = _mm_movemask_epi8(shift);

dst[0] = 0xff000000 | ((move & 0xff) << 8);

dst[1] = 0xff000000 | (move & 0xff00);

}

break;

}

}

if (x != width) {

VP8LBundleColorMap_C(row + x, width - x, xbits, dst);

}

}

//------------------------------------------------------------------------------

// Batch version of Predictor Transform subtraction

static WEBP_INLINE void Average2_m128i(const __m128i* const a0,

const __m128i* const a1,

__m128i* const avg) {

// (a + b) >> 1 = ((a + b + 1) >> 1) - ((a ^ b) & 1)

const __m128i ones = _mm_set1_epi8(1);

const __m128i avg1 = _mm_avg_epu8(*a0, *a1);

const __m128i one = _mm_and_si128(_mm_xor_si128(*a0, *a1), ones);

*avg = _mm_sub_epi8(avg1, one);

}

// Predictor0: ARGB_BLACK.

static void PredictorSub0_SSE2(const uint32_t* in, const uint32_t* upper,

int num_pixels, uint32_t* out) {

int i;

const __m128i black = _mm_set1_epi32(ARGB_BLACK);

for (i = 0; i + 4 <= num_pixels; i += 4) {

const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);

const __m128i res = _mm_sub_epi8(src, black);

_mm_storeu_si128((__m128i*)&out[i], res);

}

if (i != num_pixels) {

VP8LPredictorsSub_C[0](in + i, upper + i, num_pixels - i, out + i);

}

}

#define GENERATE_PREDICTOR_1(X, IN) \

static void PredictorSub##X##_SSE2(const uint32_t* in, const uint32_t* upper, \

int num_pixels, uint32_t* out) { \

int i; \

for (i = 0; i + 4 <= num_pixels; i += 4) { \

const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]); \

const __m128i pred = _mm_loadu_si128((const __m128i*)&(IN)); \

const __m128i res = _mm_sub_epi8(src, pred); \

_mm_storeu_si128((__m128i*)&out[i], res); \

} \

if (i != num_pixels) { \

VP8LPredictorsSub_C[(X)](in + i, upper + i, num_pixels - i, out + i); \

} \

}

GENERATE_PREDICTOR_1(1, in[i - 1]) // Predictor1: L

GENERATE_PREDICTOR_1(2, upper[i]) // Predictor2: T

GENERATE_PREDICTOR_1(3, upper[i + 1]) // Predictor3: TR

GENERATE_PREDICTOR_1(4, upper[i - 1]) // Predictor4: TL

#undef GENERATE_PREDICTOR_1

// Predictor5: avg2(avg2(L, TR), T)

static void PredictorSub5_SSE2(const uint32_t* in, const uint32_t* upper,

int num_pixels, uint32_t* out) {

int i;

for (i = 0; i + 4 <= num_pixels; i += 4) {

const __m128i L = _mm_loadu_si128((const __m128i*)&in[i - 1]);

const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);

const __m128i TR = _mm_loadu_si128((const __m128i*)&upper[i + 1]);

const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);

__m128i avg, pred, res;

Average2_m128i(&L, &TR, &avg);

Average2_m128i(&avg, &T, &pred);

res = _mm_sub_epi8(src, pred);

_mm_storeu_si128((__m128i*)&out[i], res);

}

if (i != num_pixels) {

VP8LPredictorsSub_C[5](in + i, upper + i, num_pixels - i, out + i);

}

}

#define GENERATE_PREDICTOR_2(X, A, B) \

static void PredictorSub##X##_SSE2(const uint32_t* in, const uint32_t* upper, \

int num_pixels, uint32_t* out) { \

int i; \

for (i = 0; i + 4 <= num_pixels; i += 4) { \

const __m128i tA = _mm_loadu_si128((const __m128i*)&(A)); \

const __m128i tB = _mm_loadu_si128((const __m128i*)&(B)); \

const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]); \

__m128i pred, res; \

Average2_m128i(&tA, &tB, &pred); \

res = _mm_sub_epi8(src, pred); \

_mm_storeu_si128((__m128i*)&out[i], res); \

} \

if (i != num_pixels) { \

VP8LPredictorsSub_C[(X)](in + i, upper + i, num_pixels - i, out + i); \

} \

}

GENERATE_PREDICTOR_2(6, in[i - 1], upper[i - 1]) // Predictor6: avg(L, TL)

GENERATE_PREDICTOR_2(7, in[i - 1], upper[i]) // Predictor7: avg(L, T)

GENERATE_PREDICTOR_2(8, upper[i - 1], upper[i]) // Predictor8: avg(TL, T)

GENERATE_PREDICTOR_2(9, upper[i], upper[i + 1]) // Predictor9: average(T, TR)

#undef GENERATE_PREDICTOR_2

// Predictor10: avg(avg(L,TL), avg(T, TR)).

static void PredictorSub10_SSE2(const uint32_t* in, const uint32_t* upper,

int num_pixels, uint32_t* out) {

int i;

for (i = 0; i + 4 <= num_pixels; i += 4) {

const __m128i L = _mm_loadu_si128((const __m128i*)&in[i - 1]);

const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);

const __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);

const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);

const __m128i TR = _mm_loadu_si128((const __m128i*)&upper[i + 1]);

__m128i avgTTR, avgLTL, avg, res;

Average2_m128i(&T, &TR, &avgTTR);

Average2_m128i(&L, &TL, &avgLTL);

Average2_m128i(&avgTTR, &avgLTL, &avg);

res = _mm_sub_epi8(src, avg);

_mm_storeu_si128((__m128i*)&out[i], res);

}

if (i != num_pixels) {

VP8LPredictorsSub_C[10](in + i, upper + i, num_pixels - i, out + i);

}

}

// Predictor11: select.

static void GetSumAbsDiff32_SSE2(const __m128i* const A, const __m128i* const B,

__m128i* const out) {

// We can unpack with any value on the upper 32 bits, provided it's the same

// on both operands (to that their sum of abs diff is zero). Here we use *A.

const __m128i A_lo = _mm_unpacklo_epi32(*A, *A);

const __m128i B_lo = _mm_unpacklo_epi32(*B, *A);

const __m128i A_hi = _mm_unpackhi_epi32(*A, *A);

const __m128i B_hi = _mm_unpackhi_epi32(*B, *A);

const __m128i s_lo = _mm_sad_epu8(A_lo, B_lo);

const __m128i s_hi = _mm_sad_epu8(A_hi, B_hi);

*out = _mm_packs_epi32(s_lo, s_hi);

}

static void PredictorSub11_SSE2(const uint32_t* in, const uint32_t* upper,

int num_pixels, uint32_t* out) {

int i;

for (i = 0; i + 4 <= num_pixels; i += 4) {

const __m128i L = _mm_loadu_si128((const __m128i*)&in[i - 1]);

const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);

const __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);

const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);

__m128i pa, pb;

GetSumAbsDiff32_SSE2(&T, &TL, &pa); // pa = sum |T-TL|

GetSumAbsDiff32_SSE2(&L, &TL, &pb); // pb = sum |L-TL|

{

const __m128i mask = _mm_cmpgt_epi32(pb, pa);

const __m128i A = _mm_and_si128(mask, L);

const __m128i B = _mm_andnot_si128(mask, T);

const __m128i pred = _mm_or_si128(A, B); // pred = (L > T)? L : T

const __m128i res = _mm_sub_epi8(src, pred);

_mm_storeu_si128((__m128i*)&out[i], res);

}

}

if (i != num_pixels) {

VP8LPredictorsSub_C[11](in + i, upper + i, num_pixels - i, out + i);

}

}

// Predictor12: ClampedSubSubtractFull.

static void PredictorSub12_SSE2(const uint32_t* in, const uint32_t* upper,

int num_pixels, uint32_t* out) {

int i;

const __m128i zero = _mm_setzero_si128();

for (i = 0; i + 4 <= num_pixels; i += 4) {

const __m128i src = _mm_loadu_si128((const __m128i*)&in[i]);

const __m128i L = _mm_loadu_si128((const __m128i*)&in[i - 1]);

const __m128i L_lo = _mm_unpacklo_epi8(L, zero);

const __m128i L_hi = _mm_unpackhi_epi8(L, zero);

const __m128i T = _mm_loadu_si128((const __m128i*)&upper[i]);

const __m128i T_lo = _mm_unpacklo_epi8(T, zero);

const __m128i T_hi = _mm_unpackhi_epi8(T, zero);

const __m128i TL = _mm_loadu_si128((const __m128i*)&upper[i - 1]);

const __m128i TL_lo = _mm_unpacklo_epi8(TL, zero);

const __m128i TL_hi = _mm_unpackhi_epi8(TL, zero);

const __m128i diff_lo = _mm_sub_epi16(T_lo, TL_lo);

const __m128i diff_hi = _mm_sub_epi16(T_hi, TL_hi);

const __m128i pred_lo = _mm_add_epi16(L_lo, diff_lo);

const __m128i pred_hi = _mm_add_epi16(L_hi, diff_hi);

const __m128i pred = _mm_packus_epi16(pred_lo, pred_hi);

const __m128i res = _mm_sub_epi8(src, pred);

_mm_storeu_si128((__m128i*)&out[i], res);

}

if (i != num_pixels) {

VP8LPredictorsSub_C[12](in + i, upper + i, num_pixels - i, out + i);

}

}

// Predictors13: ClampedAddSubtractHalf

static void PredictorSub13_SSE2(const uint32_t* in, const uint32_t* upper,

int num_pixels, uint32_t* out) {

int i;

const __m128i zero = _mm_setzero_si128();

for (i = 0; i + 2 <= num_pixels; i += 2) {

// we can only process two pixels at a time

const __m128i L = _mm_loadl_epi64((const __m128i*)&in[i - 1]);

const __m128i src = _mm_loadl_epi64((const __m128i*)&in[i]);

const __m128i T = _mm_loadl_epi64((const __m128i*)&upper[i]);

const __m128i TL = _mm_loadl_epi64((const __m128i*)&upper[i - 1]);

const __m128i L_lo = _mm_unpacklo_epi8(L, zero);

const __m128i T_lo = _mm_unpacklo_epi8(T, zero);

const __m128i TL_lo = _mm_unpacklo_epi8(TL, zero);

const __m128i sum = _mm_add_epi16(T_lo, L_lo);

const __m128i avg = _mm_srli_epi16(sum, 1);

const __m128i A1 = _mm_sub_epi16(avg, TL_lo);

const __m128i bit_fix = _mm_cmpgt_epi16(TL_lo, avg);

const __m128i A2 = _mm_sub_epi16(A1, bit_fix);

const __m128i A3 = _mm_srai_epi16(A2, 1);

const __m128i A4 = _mm_add_epi16(avg, A3);

const __m128i pred = _mm_packus_epi16(A4, A4);

const __m128i res = _mm_sub_epi8(src, pred);

_mm_storel_epi64((__m128i*)&out[i], res);

}

if (i != num_pixels) {

VP8LPredictorsSub_C[13](in + i, upper + i, num_pixels - i, out + i);

}

}

//------------------------------------------------------------------------------

// Entry point

extern void VP8LEncDspInitSSE2(void);

WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInitSSE2(void) {

VP8LSubtractGreenFromBlueAndRed = SubtractGreenFromBlueAndRed_SSE2;

VP8LTransformColor = TransformColor_SSE2;

VP8LCollectColorBlueTransforms = CollectColorBlueTransforms_SSE2;

VP8LCollectColorRedTransforms = CollectColorRedTransforms_SSE2;

VP8LHistogramAdd = HistogramAdd_SSE2;

VP8LCombinedShannonEntropy = CombinedShannonEntropy_SSE2;

VP8LVectorMismatch = VectorMismatch_SSE2;

VP8LBundleColorMap = BundleColorMap_SSE2;

VP8LPredictorsSub[0] = PredictorSub0_SSE2;

VP8LPredictorsSub[1] = PredictorSub1_SSE2;

VP8LPredictorsSub[2] = PredictorSub2_SSE2;

VP8LPredictorsSub[3] = PredictorSub3_SSE2;

VP8LPredictorsSub[4] = PredictorSub4_SSE2;

VP8LPredictorsSub[5] = PredictorSub5_SSE2;

VP8LPredictorsSub[6] = PredictorSub6_SSE2;

VP8LPredictorsSub[7] = PredictorSub7_SSE2;

VP8LPredictorsSub[8] = PredictorSub8_SSE2;

VP8LPredictorsSub[9] = PredictorSub9_SSE2;

VP8LPredictorsSub[10] = PredictorSub10_SSE2;

VP8LPredictorsSub[11] = PredictorSub11_SSE2;

VP8LPredictorsSub[12] = PredictorSub12_SSE2;

VP8LPredictorsSub[13] = PredictorSub13_SSE2;

VP8LPredictorsSub[14] = PredictorSub0_SSE2; // <- padding security sentinels

VP8LPredictorsSub[15] = PredictorSub0_SSE2;

}

#else // !WEBP_USE_SSE2

WEBP_DSP_INIT_STUB(VP8LEncDspInitSSE2)

#endif // WEBP_USE_SSE2