1// Copyright 2011 Google Inc. All Rights Reserved. 2// 3// Use of this source code is governed by a BSD-style license 4// that can be found in the COPYING file in the root of the source 5// tree. An additional intellectual property rights grant can be found 6// in the file PATENTS. All contributing project authors may 7// be found in the AUTHORS file in the root of the source tree. 8// ----------------------------------------------------------------------------- 9// 10// SSE2 version of speed-critical encoding functions. 11// 12// Author: Christian Duvivier (cduvivier@google.com) 13 14#include "./dsp.h" 15 16#if defined(WEBP_USE_SSE2) 17#include <stdlib.h> // for abs() 18#include <emmintrin.h> 19 20#include "../enc/cost.h" 21#include "../enc/vp8enci.h" 22#include "../utils/utils.h" 23 24//------------------------------------------------------------------------------ 25// Quite useful macro for debugging. Left here for convenience. 26 27#if 0 28#include <stdio.h> 29static void PrintReg(const __m128i r, const char* const name, int size) { 30 int n; 31 union { 32 __m128i r; 33 uint8_t i8[16]; 34 uint16_t i16[8]; 35 uint32_t i32[4]; 36 uint64_t i64[2]; 37 } tmp; 38 tmp.r = r; 39 printf("%s\t: ", name); 40 if (size == 8) { 41 for (n = 0; n < 16; ++n) printf("%.2x ", tmp.i8[n]); 42 } else if (size == 16) { 43 for (n = 0; n < 8; ++n) printf("%.4x ", tmp.i16[n]); 44 } else if (size == 32) { 45 for (n = 0; n < 4; ++n) printf("%.8x ", tmp.i32[n]); 46 } else { 47 for (n = 0; n < 2; ++n) printf("%.16lx ", tmp.i64[n]); 48 } 49 printf("\n"); 50} 51#endif 52 53//------------------------------------------------------------------------------ 54// Compute susceptibility based on DCT-coeff histograms: 55// the higher, the "easier" the macroblock is to compress. 56 57static void CollectHistogram(const uint8_t* ref, const uint8_t* pred, 58 int start_block, int end_block, 59 VP8Histogram* const histo) { 60 const __m128i max_coeff_thresh = _mm_set1_epi16(MAX_COEFF_THRESH); 61 int j; 62 for (j = start_block; j < end_block; ++j) { 63 int16_t out[16]; 64 int k; 65 66 VP8FTransform(ref + VP8DspScan[j], pred + VP8DspScan[j], out); 67 68 // Convert coefficients to bin (within out[]). 69 { 70 // Load. 71 const __m128i out0 = _mm_loadu_si128((__m128i*)&out[0]); 72 const __m128i out1 = _mm_loadu_si128((__m128i*)&out[8]); 73 // sign(out) = out >> 15 (0x0000 if positive, 0xffff if negative) 74 const __m128i sign0 = _mm_srai_epi16(out0, 15); 75 const __m128i sign1 = _mm_srai_epi16(out1, 15); 76 // abs(out) = (out ^ sign) - sign 77 const __m128i xor0 = _mm_xor_si128(out0, sign0); 78 const __m128i xor1 = _mm_xor_si128(out1, sign1); 79 const __m128i abs0 = _mm_sub_epi16(xor0, sign0); 80 const __m128i abs1 = _mm_sub_epi16(xor1, sign1); 81 // v = abs(out) >> 3 82 const __m128i v0 = _mm_srai_epi16(abs0, 3); 83 const __m128i v1 = _mm_srai_epi16(abs1, 3); 84 // bin = min(v, MAX_COEFF_THRESH) 85 const __m128i bin0 = _mm_min_epi16(v0, max_coeff_thresh); 86 const __m128i bin1 = _mm_min_epi16(v1, max_coeff_thresh); 87 // Store. 88 _mm_storeu_si128((__m128i*)&out[0], bin0); 89 _mm_storeu_si128((__m128i*)&out[8], bin1); 90 } 91 92 // Convert coefficients to bin. 93 for (k = 0; k < 16; ++k) { 94 histo->distribution[out[k]]++; 95 } 96 } 97} 98 99//------------------------------------------------------------------------------ 100// Transforms (Paragraph 14.4) 101 102// Does one or two inverse transforms. 103static void ITransform(const uint8_t* ref, const int16_t* in, uint8_t* dst, 104 int do_two) { 105 // This implementation makes use of 16-bit fixed point versions of two 106 // multiply constants: 107 // K1 = sqrt(2) * cos (pi/8) ~= 85627 / 2^16 108 // K2 = sqrt(2) * sin (pi/8) ~= 35468 / 2^16 109 // 110 // To be able to use signed 16-bit integers, we use the following trick to 111 // have constants within range: 112 // - Associated constants are obtained by subtracting the 16-bit fixed point 113 // version of one: 114 // k = K - (1 << 16) => K = k + (1 << 16) 115 // K1 = 85267 => k1 = 20091 116 // K2 = 35468 => k2 = -30068 117 // - The multiplication of a variable by a constant become the sum of the 118 // variable and the multiplication of that variable by the associated 119 // constant: 120 // (x * K) >> 16 = (x * (k + (1 << 16))) >> 16 = ((x * k ) >> 16) + x 121 const __m128i k1 = _mm_set1_epi16(20091); 122 const __m128i k2 = _mm_set1_epi16(-30068); 123 __m128i T0, T1, T2, T3; 124 125 // Load and concatenate the transform coefficients (we'll do two inverse 126 // transforms in parallel). In the case of only one inverse transform, the 127 // second half of the vectors will just contain random value we'll never 128 // use nor store. 129 __m128i in0, in1, in2, in3; 130 { 131 in0 = _mm_loadl_epi64((__m128i*)&in[0]); 132 in1 = _mm_loadl_epi64((__m128i*)&in[4]); 133 in2 = _mm_loadl_epi64((__m128i*)&in[8]); 134 in3 = _mm_loadl_epi64((__m128i*)&in[12]); 135 // a00 a10 a20 a30 x x x x 136 // a01 a11 a21 a31 x x x x 137 // a02 a12 a22 a32 x x x x 138 // a03 a13 a23 a33 x x x x 139 if (do_two) { 140 const __m128i inB0 = _mm_loadl_epi64((__m128i*)&in[16]); 141 const __m128i inB1 = _mm_loadl_epi64((__m128i*)&in[20]); 142 const __m128i inB2 = _mm_loadl_epi64((__m128i*)&in[24]); 143 const __m128i inB3 = _mm_loadl_epi64((__m128i*)&in[28]); 144 in0 = _mm_unpacklo_epi64(in0, inB0); 145 in1 = _mm_unpacklo_epi64(in1, inB1); 146 in2 = _mm_unpacklo_epi64(in2, inB2); 147 in3 = _mm_unpacklo_epi64(in3, inB3); 148 // a00 a10 a20 a30 b00 b10 b20 b30 149 // a01 a11 a21 a31 b01 b11 b21 b31 150 // a02 a12 a22 a32 b02 b12 b22 b32 151 // a03 a13 a23 a33 b03 b13 b23 b33 152 } 153 } 154 155 // Vertical pass and subsequent transpose. 156 { 157 // First pass, c and d calculations are longer because of the "trick" 158 // multiplications. 159 const __m128i a = _mm_add_epi16(in0, in2); 160 const __m128i b = _mm_sub_epi16(in0, in2); 161 // c = MUL(in1, K2) - MUL(in3, K1) = MUL(in1, k2) - MUL(in3, k1) + in1 - in3 162 const __m128i c1 = _mm_mulhi_epi16(in1, k2); 163 const __m128i c2 = _mm_mulhi_epi16(in3, k1); 164 const __m128i c3 = _mm_sub_epi16(in1, in3); 165 const __m128i c4 = _mm_sub_epi16(c1, c2); 166 const __m128i c = _mm_add_epi16(c3, c4); 167 // d = MUL(in1, K1) + MUL(in3, K2) = MUL(in1, k1) + MUL(in3, k2) + in1 + in3 168 const __m128i d1 = _mm_mulhi_epi16(in1, k1); 169 const __m128i d2 = _mm_mulhi_epi16(in3, k2); 170 const __m128i d3 = _mm_add_epi16(in1, in3); 171 const __m128i d4 = _mm_add_epi16(d1, d2); 172 const __m128i d = _mm_add_epi16(d3, d4); 173 174 // Second pass. 175 const __m128i tmp0 = _mm_add_epi16(a, d); 176 const __m128i tmp1 = _mm_add_epi16(b, c); 177 const __m128i tmp2 = _mm_sub_epi16(b, c); 178 const __m128i tmp3 = _mm_sub_epi16(a, d); 179 180 // Transpose the two 4x4. 181 // a00 a01 a02 a03 b00 b01 b02 b03 182 // a10 a11 a12 a13 b10 b11 b12 b13 183 // a20 a21 a22 a23 b20 b21 b22 b23 184 // a30 a31 a32 a33 b30 b31 b32 b33 185 const __m128i transpose0_0 = _mm_unpacklo_epi16(tmp0, tmp1); 186 const __m128i transpose0_1 = _mm_unpacklo_epi16(tmp2, tmp3); 187 const __m128i transpose0_2 = _mm_unpackhi_epi16(tmp0, tmp1); 188 const __m128i transpose0_3 = _mm_unpackhi_epi16(tmp2, tmp3); 189 // a00 a10 a01 a11 a02 a12 a03 a13 190 // a20 a30 a21 a31 a22 a32 a23 a33 191 // b00 b10 b01 b11 b02 b12 b03 b13 192 // b20 b30 b21 b31 b22 b32 b23 b33 193 const __m128i transpose1_0 = _mm_unpacklo_epi32(transpose0_0, transpose0_1); 194 const __m128i transpose1_1 = _mm_unpacklo_epi32(transpose0_2, transpose0_3); 195 const __m128i transpose1_2 = _mm_unpackhi_epi32(transpose0_0, transpose0_1); 196 const __m128i transpose1_3 = _mm_unpackhi_epi32(transpose0_2, transpose0_3); 197 // a00 a10 a20 a30 a01 a11 a21 a31 198 // b00 b10 b20 b30 b01 b11 b21 b31 199 // a02 a12 a22 a32 a03 a13 a23 a33 200 // b02 b12 a22 b32 b03 b13 b23 b33 201 T0 = _mm_unpacklo_epi64(transpose1_0, transpose1_1); 202 T1 = _mm_unpackhi_epi64(transpose1_0, transpose1_1); 203 T2 = _mm_unpacklo_epi64(transpose1_2, transpose1_3); 204 T3 = _mm_unpackhi_epi64(transpose1_2, transpose1_3); 205 // a00 a10 a20 a30 b00 b10 b20 b30 206 // a01 a11 a21 a31 b01 b11 b21 b31 207 // a02 a12 a22 a32 b02 b12 b22 b32 208 // a03 a13 a23 a33 b03 b13 b23 b33 209 } 210 211 // Horizontal pass and subsequent transpose. 212 { 213 // First pass, c and d calculations are longer because of the "trick" 214 // multiplications. 215 const __m128i four = _mm_set1_epi16(4); 216 const __m128i dc = _mm_add_epi16(T0, four); 217 const __m128i a = _mm_add_epi16(dc, T2); 218 const __m128i b = _mm_sub_epi16(dc, T2); 219 // c = MUL(T1, K2) - MUL(T3, K1) = MUL(T1, k2) - MUL(T3, k1) + T1 - T3 220 const __m128i c1 = _mm_mulhi_epi16(T1, k2); 221 const __m128i c2 = _mm_mulhi_epi16(T3, k1); 222 const __m128i c3 = _mm_sub_epi16(T1, T3); 223 const __m128i c4 = _mm_sub_epi16(c1, c2); 224 const __m128i c = _mm_add_epi16(c3, c4); 225 // d = MUL(T1, K1) + MUL(T3, K2) = MUL(T1, k1) + MUL(T3, k2) + T1 + T3 226 const __m128i d1 = _mm_mulhi_epi16(T1, k1); 227 const __m128i d2 = _mm_mulhi_epi16(T3, k2); 228 const __m128i d3 = _mm_add_epi16(T1, T3); 229 const __m128i d4 = _mm_add_epi16(d1, d2); 230 const __m128i d = _mm_add_epi16(d3, d4); 231 232 // Second pass. 233 const __m128i tmp0 = _mm_add_epi16(a, d); 234 const __m128i tmp1 = _mm_add_epi16(b, c); 235 const __m128i tmp2 = _mm_sub_epi16(b, c); 236 const __m128i tmp3 = _mm_sub_epi16(a, d); 237 const __m128i shifted0 = _mm_srai_epi16(tmp0, 3); 238 const __m128i shifted1 = _mm_srai_epi16(tmp1, 3); 239 const __m128i shifted2 = _mm_srai_epi16(tmp2, 3); 240 const __m128i shifted3 = _mm_srai_epi16(tmp3, 3); 241 242 // Transpose the two 4x4. 243 // a00 a01 a02 a03 b00 b01 b02 b03 244 // a10 a11 a12 a13 b10 b11 b12 b13 245 // a20 a21 a22 a23 b20 b21 b22 b23 246 // a30 a31 a32 a33 b30 b31 b32 b33 247 const __m128i transpose0_0 = _mm_unpacklo_epi16(shifted0, shifted1); 248 const __m128i transpose0_1 = _mm_unpacklo_epi16(shifted2, shifted3); 249 const __m128i transpose0_2 = _mm_unpackhi_epi16(shifted0, shifted1); 250 const __m128i transpose0_3 = _mm_unpackhi_epi16(shifted2, shifted3); 251 // a00 a10 a01 a11 a02 a12 a03 a13 252 // a20 a30 a21 a31 a22 a32 a23 a33 253 // b00 b10 b01 b11 b02 b12 b03 b13 254 // b20 b30 b21 b31 b22 b32 b23 b33 255 const __m128i transpose1_0 = _mm_unpacklo_epi32(transpose0_0, transpose0_1); 256 const __m128i transpose1_1 = _mm_unpacklo_epi32(transpose0_2, transpose0_3); 257 const __m128i transpose1_2 = _mm_unpackhi_epi32(transpose0_0, transpose0_1); 258 const __m128i transpose1_3 = _mm_unpackhi_epi32(transpose0_2, transpose0_3); 259 // a00 a10 a20 a30 a01 a11 a21 a31 260 // b00 b10 b20 b30 b01 b11 b21 b31 261 // a02 a12 a22 a32 a03 a13 a23 a33 262 // b02 b12 a22 b32 b03 b13 b23 b33 263 T0 = _mm_unpacklo_epi64(transpose1_0, transpose1_1); 264 T1 = _mm_unpackhi_epi64(transpose1_0, transpose1_1); 265 T2 = _mm_unpacklo_epi64(transpose1_2, transpose1_3); 266 T3 = _mm_unpackhi_epi64(transpose1_2, transpose1_3); 267 // a00 a10 a20 a30 b00 b10 b20 b30 268 // a01 a11 a21 a31 b01 b11 b21 b31 269 // a02 a12 a22 a32 b02 b12 b22 b32 270 // a03 a13 a23 a33 b03 b13 b23 b33 271 } 272 273 // Add inverse transform to 'ref' and store. 274 { 275 const __m128i zero = _mm_setzero_si128(); 276 // Load the reference(s). 277 __m128i ref0, ref1, ref2, ref3; 278 if (do_two) { 279 // Load eight bytes/pixels per line. 280 ref0 = _mm_loadl_epi64((__m128i*)&ref[0 * BPS]); 281 ref1 = _mm_loadl_epi64((__m128i*)&ref[1 * BPS]); 282 ref2 = _mm_loadl_epi64((__m128i*)&ref[2 * BPS]); 283 ref3 = _mm_loadl_epi64((__m128i*)&ref[3 * BPS]); 284 } else { 285 // Load four bytes/pixels per line. 286 ref0 = _mm_cvtsi32_si128(*(int*)&ref[0 * BPS]); 287 ref1 = _mm_cvtsi32_si128(*(int*)&ref[1 * BPS]); 288 ref2 = _mm_cvtsi32_si128(*(int*)&ref[2 * BPS]); 289 ref3 = _mm_cvtsi32_si128(*(int*)&ref[3 * BPS]); 290 } 291 // Convert to 16b. 292 ref0 = _mm_unpacklo_epi8(ref0, zero); 293 ref1 = _mm_unpacklo_epi8(ref1, zero); 294 ref2 = _mm_unpacklo_epi8(ref2, zero); 295 ref3 = _mm_unpacklo_epi8(ref3, zero); 296 // Add the inverse transform(s). 297 ref0 = _mm_add_epi16(ref0, T0); 298 ref1 = _mm_add_epi16(ref1, T1); 299 ref2 = _mm_add_epi16(ref2, T2); 300 ref3 = _mm_add_epi16(ref3, T3); 301 // Unsigned saturate to 8b. 302 ref0 = _mm_packus_epi16(ref0, ref0); 303 ref1 = _mm_packus_epi16(ref1, ref1); 304 ref2 = _mm_packus_epi16(ref2, ref2); 305 ref3 = _mm_packus_epi16(ref3, ref3); 306 // Store the results. 307 if (do_two) { 308 // Store eight bytes/pixels per line. 309 _mm_storel_epi64((__m128i*)&dst[0 * BPS], ref0); 310 _mm_storel_epi64((__m128i*)&dst[1 * BPS], ref1); 311 _mm_storel_epi64((__m128i*)&dst[2 * BPS], ref2); 312 _mm_storel_epi64((__m128i*)&dst[3 * BPS], ref3); 313 } else { 314 // Store four bytes/pixels per line. 315 *((int32_t *)&dst[0 * BPS]) = _mm_cvtsi128_si32(ref0); 316 *((int32_t *)&dst[1 * BPS]) = _mm_cvtsi128_si32(ref1); 317 *((int32_t *)&dst[2 * BPS]) = _mm_cvtsi128_si32(ref2); 318 *((int32_t *)&dst[3 * BPS]) = _mm_cvtsi128_si32(ref3); 319 } 320 } 321} 322 323static void FTransform(const uint8_t* src, const uint8_t* ref, int16_t* out) { 324 const __m128i zero = _mm_setzero_si128(); 325 const __m128i seven = _mm_set1_epi16(7); 326 const __m128i k937 = _mm_set1_epi32(937); 327 const __m128i k1812 = _mm_set1_epi32(1812); 328 const __m128i k51000 = _mm_set1_epi32(51000); 329 const __m128i k12000_plus_one = _mm_set1_epi32(12000 + (1 << 16)); 330 const __m128i k5352_2217 = _mm_set_epi16(5352, 2217, 5352, 2217, 331 5352, 2217, 5352, 2217); 332 const __m128i k2217_5352 = _mm_set_epi16(2217, -5352, 2217, -5352, 333 2217, -5352, 2217, -5352); 334 const __m128i k88p = _mm_set_epi16(8, 8, 8, 8, 8, 8, 8, 8); 335 const __m128i k88m = _mm_set_epi16(-8, 8, -8, 8, -8, 8, -8, 8); 336 const __m128i k5352_2217p = _mm_set_epi16(2217, 5352, 2217, 5352, 337 2217, 5352, 2217, 5352); 338 const __m128i k5352_2217m = _mm_set_epi16(-5352, 2217, -5352, 2217, 339 -5352, 2217, -5352, 2217); 340 __m128i v01, v32; 341 342 343 // Difference between src and ref and initial transpose. 344 { 345 // Load src and convert to 16b. 346 const __m128i src0 = _mm_loadl_epi64((__m128i*)&src[0 * BPS]); 347 const __m128i src1 = _mm_loadl_epi64((__m128i*)&src[1 * BPS]); 348 const __m128i src2 = _mm_loadl_epi64((__m128i*)&src[2 * BPS]); 349 const __m128i src3 = _mm_loadl_epi64((__m128i*)&src[3 * BPS]); 350 const __m128i src_0 = _mm_unpacklo_epi8(src0, zero); 351 const __m128i src_1 = _mm_unpacklo_epi8(src1, zero); 352 const __m128i src_2 = _mm_unpacklo_epi8(src2, zero); 353 const __m128i src_3 = _mm_unpacklo_epi8(src3, zero); 354 // Load ref and convert to 16b. 355 const __m128i ref0 = _mm_loadl_epi64((__m128i*)&ref[0 * BPS]); 356 const __m128i ref1 = _mm_loadl_epi64((__m128i*)&ref[1 * BPS]); 357 const __m128i ref2 = _mm_loadl_epi64((__m128i*)&ref[2 * BPS]); 358 const __m128i ref3 = _mm_loadl_epi64((__m128i*)&ref[3 * BPS]); 359 const __m128i ref_0 = _mm_unpacklo_epi8(ref0, zero); 360 const __m128i ref_1 = _mm_unpacklo_epi8(ref1, zero); 361 const __m128i ref_2 = _mm_unpacklo_epi8(ref2, zero); 362 const __m128i ref_3 = _mm_unpacklo_epi8(ref3, zero); 363 // Compute difference. -> 00 01 02 03 00 00 00 00 364 const __m128i diff0 = _mm_sub_epi16(src_0, ref_0); 365 const __m128i diff1 = _mm_sub_epi16(src_1, ref_1); 366 const __m128i diff2 = _mm_sub_epi16(src_2, ref_2); 367 const __m128i diff3 = _mm_sub_epi16(src_3, ref_3); 368 369 370 // Unpack and shuffle 371 // 00 01 02 03 0 0 0 0 372 // 10 11 12 13 0 0 0 0 373 // 20 21 22 23 0 0 0 0 374 // 30 31 32 33 0 0 0 0 375 const __m128i shuf01 = _mm_unpacklo_epi32(diff0, diff1); 376 const __m128i shuf23 = _mm_unpacklo_epi32(diff2, diff3); 377 // 00 01 10 11 02 03 12 13 378 // 20 21 30 31 22 23 32 33 379 const __m128i shuf01_p = 380 _mm_shufflehi_epi16(shuf01, _MM_SHUFFLE(2, 3, 0, 1)); 381 const __m128i shuf23_p = 382 _mm_shufflehi_epi16(shuf23, _MM_SHUFFLE(2, 3, 0, 1)); 383 // 00 01 10 11 03 02 13 12 384 // 20 21 30 31 23 22 33 32 385 const __m128i s01 = _mm_unpacklo_epi64(shuf01_p, shuf23_p); 386 const __m128i s32 = _mm_unpackhi_epi64(shuf01_p, shuf23_p); 387 // 00 01 10 11 20 21 30 31 388 // 03 02 13 12 23 22 33 32 389 const __m128i a01 = _mm_add_epi16(s01, s32); 390 const __m128i a32 = _mm_sub_epi16(s01, s32); 391 // [d0 + d3 | d1 + d2 | ...] = [a0 a1 | a0' a1' | ... ] 392 // [d0 - d3 | d1 - d2 | ...] = [a3 a2 | a3' a2' | ... ] 393 394 const __m128i tmp0 = _mm_madd_epi16(a01, k88p); // [ (a0 + a1) << 3, ... ] 395 const __m128i tmp2 = _mm_madd_epi16(a01, k88m); // [ (a0 - a1) << 3, ... ] 396 const __m128i tmp1_1 = _mm_madd_epi16(a32, k5352_2217p); 397 const __m128i tmp3_1 = _mm_madd_epi16(a32, k5352_2217m); 398 const __m128i tmp1_2 = _mm_add_epi32(tmp1_1, k1812); 399 const __m128i tmp3_2 = _mm_add_epi32(tmp3_1, k937); 400 const __m128i tmp1 = _mm_srai_epi32(tmp1_2, 9); 401 const __m128i tmp3 = _mm_srai_epi32(tmp3_2, 9); 402 const __m128i s03 = _mm_packs_epi32(tmp0, tmp2); 403 const __m128i s12 = _mm_packs_epi32(tmp1, tmp3); 404 const __m128i s_lo = _mm_unpacklo_epi16(s03, s12); // 0 1 0 1 0 1... 405 const __m128i s_hi = _mm_unpackhi_epi16(s03, s12); // 2 3 2 3 2 3 406 const __m128i v23 = _mm_unpackhi_epi32(s_lo, s_hi); 407 v01 = _mm_unpacklo_epi32(s_lo, s_hi); 408 v32 = _mm_shuffle_epi32(v23, _MM_SHUFFLE(1, 0, 3, 2)); // 3 2 3 2 3 2.. 409 } 410 411 // Second pass 412 { 413 // Same operations are done on the (0,3) and (1,2) pairs. 414 // a0 = v0 + v3 415 // a1 = v1 + v2 416 // a3 = v0 - v3 417 // a2 = v1 - v2 418 const __m128i a01 = _mm_add_epi16(v01, v32); 419 const __m128i a32 = _mm_sub_epi16(v01, v32); 420 const __m128i a11 = _mm_unpackhi_epi64(a01, a01); 421 const __m128i a22 = _mm_unpackhi_epi64(a32, a32); 422 const __m128i a01_plus_7 = _mm_add_epi16(a01, seven); 423 424 // d0 = (a0 + a1 + 7) >> 4; 425 // d2 = (a0 - a1 + 7) >> 4; 426 const __m128i c0 = _mm_add_epi16(a01_plus_7, a11); 427 const __m128i c2 = _mm_sub_epi16(a01_plus_7, a11); 428 const __m128i d0 = _mm_srai_epi16(c0, 4); 429 const __m128i d2 = _mm_srai_epi16(c2, 4); 430 431 // f1 = ((b3 * 5352 + b2 * 2217 + 12000) >> 16) 432 // f3 = ((b3 * 2217 - b2 * 5352 + 51000) >> 16) 433 const __m128i b23 = _mm_unpacklo_epi16(a22, a32); 434 const __m128i c1 = _mm_madd_epi16(b23, k5352_2217); 435 const __m128i c3 = _mm_madd_epi16(b23, k2217_5352); 436 const __m128i d1 = _mm_add_epi32(c1, k12000_plus_one); 437 const __m128i d3 = _mm_add_epi32(c3, k51000); 438 const __m128i e1 = _mm_srai_epi32(d1, 16); 439 const __m128i e3 = _mm_srai_epi32(d3, 16); 440 const __m128i f1 = _mm_packs_epi32(e1, e1); 441 const __m128i f3 = _mm_packs_epi32(e3, e3); 442 // f1 = f1 + (a3 != 0); 443 // The compare will return (0xffff, 0) for (==0, !=0). To turn that into the 444 // desired (0, 1), we add one earlier through k12000_plus_one. 445 // -> f1 = f1 + 1 - (a3 == 0) 446 const __m128i g1 = _mm_add_epi16(f1, _mm_cmpeq_epi16(a32, zero)); 447 448 const __m128i d0_g1 = _mm_unpacklo_epi64(d0, g1); 449 const __m128i d2_f3 = _mm_unpacklo_epi64(d2, f3); 450 _mm_storeu_si128((__m128i*)&out[0], d0_g1); 451 _mm_storeu_si128((__m128i*)&out[8], d2_f3); 452 } 453} 454 455static void FTransformWHT(const int16_t* in, int16_t* out) { 456 int32_t tmp[16]; 457 int i; 458 for (i = 0; i < 4; ++i, in += 64) { 459 const int a0 = (in[0 * 16] + in[2 * 16]); 460 const int a1 = (in[1 * 16] + in[3 * 16]); 461 const int a2 = (in[1 * 16] - in[3 * 16]); 462 const int a3 = (in[0 * 16] - in[2 * 16]); 463 tmp[0 + i * 4] = a0 + a1; 464 tmp[1 + i * 4] = a3 + a2; 465 tmp[2 + i * 4] = a3 - a2; 466 tmp[3 + i * 4] = a0 - a1; 467 } 468 { 469 const __m128i src0 = _mm_loadu_si128((__m128i*)&tmp[0]); 470 const __m128i src1 = _mm_loadu_si128((__m128i*)&tmp[4]); 471 const __m128i src2 = _mm_loadu_si128((__m128i*)&tmp[8]); 472 const __m128i src3 = _mm_loadu_si128((__m128i*)&tmp[12]); 473 const __m128i a0 = _mm_add_epi32(src0, src2); 474 const __m128i a1 = _mm_add_epi32(src1, src3); 475 const __m128i a2 = _mm_sub_epi32(src1, src3); 476 const __m128i a3 = _mm_sub_epi32(src0, src2); 477 const __m128i b0 = _mm_srai_epi32(_mm_add_epi32(a0, a1), 1); 478 const __m128i b1 = _mm_srai_epi32(_mm_add_epi32(a3, a2), 1); 479 const __m128i b2 = _mm_srai_epi32(_mm_sub_epi32(a3, a2), 1); 480 const __m128i b3 = _mm_srai_epi32(_mm_sub_epi32(a0, a1), 1); 481 const __m128i out0 = _mm_packs_epi32(b0, b1); 482 const __m128i out1 = _mm_packs_epi32(b2, b3); 483 _mm_storeu_si128((__m128i*)&out[0], out0); 484 _mm_storeu_si128((__m128i*)&out[8], out1); 485 } 486} 487 488//------------------------------------------------------------------------------ 489// Metric 490 491static int SSE_Nx4(const uint8_t* a, const uint8_t* b, 492 int num_quads, int do_16) { 493 const __m128i zero = _mm_setzero_si128(); 494 __m128i sum1 = zero; 495 __m128i sum2 = zero; 496 497 while (num_quads-- > 0) { 498 // Note: for the !do_16 case, we read 16 pixels instead of 8 but that's ok, 499 // thanks to buffer over-allocation to that effect. 500 const __m128i a0 = _mm_loadu_si128((__m128i*)&a[BPS * 0]); 501 const __m128i a1 = _mm_loadu_si128((__m128i*)&a[BPS * 1]); 502 const __m128i a2 = _mm_loadu_si128((__m128i*)&a[BPS * 2]); 503 const __m128i a3 = _mm_loadu_si128((__m128i*)&a[BPS * 3]); 504 const __m128i b0 = _mm_loadu_si128((__m128i*)&b[BPS * 0]); 505 const __m128i b1 = _mm_loadu_si128((__m128i*)&b[BPS * 1]); 506 const __m128i b2 = _mm_loadu_si128((__m128i*)&b[BPS * 2]); 507 const __m128i b3 = _mm_loadu_si128((__m128i*)&b[BPS * 3]); 508 509 // compute clip0(a-b) and clip0(b-a) 510 const __m128i a0p = _mm_subs_epu8(a0, b0); 511 const __m128i a0m = _mm_subs_epu8(b0, a0); 512 const __m128i a1p = _mm_subs_epu8(a1, b1); 513 const __m128i a1m = _mm_subs_epu8(b1, a1); 514 const __m128i a2p = _mm_subs_epu8(a2, b2); 515 const __m128i a2m = _mm_subs_epu8(b2, a2); 516 const __m128i a3p = _mm_subs_epu8(a3, b3); 517 const __m128i a3m = _mm_subs_epu8(b3, a3); 518 519 // compute |a-b| with 8b arithmetic as clip0(a-b) | clip0(b-a) 520 const __m128i diff0 = _mm_or_si128(a0p, a0m); 521 const __m128i diff1 = _mm_or_si128(a1p, a1m); 522 const __m128i diff2 = _mm_or_si128(a2p, a2m); 523 const __m128i diff3 = _mm_or_si128(a3p, a3m); 524 525 // unpack (only four operations, instead of eight) 526 const __m128i low0 = _mm_unpacklo_epi8(diff0, zero); 527 const __m128i low1 = _mm_unpacklo_epi8(diff1, zero); 528 const __m128i low2 = _mm_unpacklo_epi8(diff2, zero); 529 const __m128i low3 = _mm_unpacklo_epi8(diff3, zero); 530 531 // multiply with self 532 const __m128i low_madd0 = _mm_madd_epi16(low0, low0); 533 const __m128i low_madd1 = _mm_madd_epi16(low1, low1); 534 const __m128i low_madd2 = _mm_madd_epi16(low2, low2); 535 const __m128i low_madd3 = _mm_madd_epi16(low3, low3); 536 537 // collect in a cascading way 538 const __m128i low_sum0 = _mm_add_epi32(low_madd0, low_madd1); 539 const __m128i low_sum1 = _mm_add_epi32(low_madd2, low_madd3); 540 sum1 = _mm_add_epi32(sum1, low_sum0); 541 sum2 = _mm_add_epi32(sum2, low_sum1); 542 543 if (do_16) { // if necessary, process the higher 8 bytes similarly 544 const __m128i hi0 = _mm_unpackhi_epi8(diff0, zero); 545 const __m128i hi1 = _mm_unpackhi_epi8(diff1, zero); 546 const __m128i hi2 = _mm_unpackhi_epi8(diff2, zero); 547 const __m128i hi3 = _mm_unpackhi_epi8(diff3, zero); 548 549 const __m128i hi_madd0 = _mm_madd_epi16(hi0, hi0); 550 const __m128i hi_madd1 = _mm_madd_epi16(hi1, hi1); 551 const __m128i hi_madd2 = _mm_madd_epi16(hi2, hi2); 552 const __m128i hi_madd3 = _mm_madd_epi16(hi3, hi3); 553 const __m128i hi_sum0 = _mm_add_epi32(hi_madd0, hi_madd1); 554 const __m128i hi_sum1 = _mm_add_epi32(hi_madd2, hi_madd3); 555 sum1 = _mm_add_epi32(sum1, hi_sum0); 556 sum2 = _mm_add_epi32(sum2, hi_sum1); 557 } 558 a += 4 * BPS; 559 b += 4 * BPS; 560 } 561 { 562 int32_t tmp[4]; 563 const __m128i sum = _mm_add_epi32(sum1, sum2); 564 _mm_storeu_si128((__m128i*)tmp, sum); 565 return (tmp[3] + tmp[2] + tmp[1] + tmp[0]); 566 } 567} 568 569static int SSE16x16(const uint8_t* a, const uint8_t* b) { 570 return SSE_Nx4(a, b, 4, 1); 571} 572 573static int SSE16x8(const uint8_t* a, const uint8_t* b) { 574 return SSE_Nx4(a, b, 2, 1); 575} 576 577static int SSE8x8(const uint8_t* a, const uint8_t* b) { 578 return SSE_Nx4(a, b, 2, 0); 579} 580 581static int SSE4x4(const uint8_t* a, const uint8_t* b) { 582 const __m128i zero = _mm_setzero_si128(); 583 584 // Load values. Note that we read 8 pixels instead of 4, 585 // but the a/b buffers are over-allocated to that effect. 586 const __m128i a0 = _mm_loadl_epi64((__m128i*)&a[BPS * 0]); 587 const __m128i a1 = _mm_loadl_epi64((__m128i*)&a[BPS * 1]); 588 const __m128i a2 = _mm_loadl_epi64((__m128i*)&a[BPS * 2]); 589 const __m128i a3 = _mm_loadl_epi64((__m128i*)&a[BPS * 3]); 590 const __m128i b0 = _mm_loadl_epi64((__m128i*)&b[BPS * 0]); 591 const __m128i b1 = _mm_loadl_epi64((__m128i*)&b[BPS * 1]); 592 const __m128i b2 = _mm_loadl_epi64((__m128i*)&b[BPS * 2]); 593 const __m128i b3 = _mm_loadl_epi64((__m128i*)&b[BPS * 3]); 594 595 // Combine pair of lines and convert to 16b. 596 const __m128i a01 = _mm_unpacklo_epi32(a0, a1); 597 const __m128i a23 = _mm_unpacklo_epi32(a2, a3); 598 const __m128i b01 = _mm_unpacklo_epi32(b0, b1); 599 const __m128i b23 = _mm_unpacklo_epi32(b2, b3); 600 const __m128i a01s = _mm_unpacklo_epi8(a01, zero); 601 const __m128i a23s = _mm_unpacklo_epi8(a23, zero); 602 const __m128i b01s = _mm_unpacklo_epi8(b01, zero); 603 const __m128i b23s = _mm_unpacklo_epi8(b23, zero); 604 605 // Compute differences; (a-b)^2 = (abs(a-b))^2 = (sat8(a-b) + sat8(b-a))^2 606 // TODO(cduvivier): Dissassemble and figure out why this is fastest. We don't 607 // need absolute values, there is no need to do calculation 608 // in 8bit as we are already in 16bit, ... Yet this is what 609 // benchmarks the fastest! 610 const __m128i d0 = _mm_subs_epu8(a01s, b01s); 611 const __m128i d1 = _mm_subs_epu8(b01s, a01s); 612 const __m128i d2 = _mm_subs_epu8(a23s, b23s); 613 const __m128i d3 = _mm_subs_epu8(b23s, a23s); 614 615 // Square and add them all together. 616 const __m128i madd0 = _mm_madd_epi16(d0, d0); 617 const __m128i madd1 = _mm_madd_epi16(d1, d1); 618 const __m128i madd2 = _mm_madd_epi16(d2, d2); 619 const __m128i madd3 = _mm_madd_epi16(d3, d3); 620 const __m128i sum0 = _mm_add_epi32(madd0, madd1); 621 const __m128i sum1 = _mm_add_epi32(madd2, madd3); 622 const __m128i sum2 = _mm_add_epi32(sum0, sum1); 623 624 int32_t tmp[4]; 625 _mm_storeu_si128((__m128i*)tmp, sum2); 626 return (tmp[3] + tmp[2] + tmp[1] + tmp[0]); 627} 628 629//------------------------------------------------------------------------------ 630// Texture distortion 631// 632// We try to match the spectral content (weighted) between source and 633// reconstructed samples. 634 635// Hadamard transform 636// Returns the difference between the weighted sum of the absolute value of 637// transformed coefficients. 638static int TTransform(const uint8_t* inA, const uint8_t* inB, 639 const uint16_t* const w) { 640 int32_t sum[4]; 641 __m128i tmp_0, tmp_1, tmp_2, tmp_3; 642 const __m128i zero = _mm_setzero_si128(); 643 644 // Load, combine and transpose inputs. 645 { 646 const __m128i inA_0 = _mm_loadl_epi64((__m128i*)&inA[BPS * 0]); 647 const __m128i inA_1 = _mm_loadl_epi64((__m128i*)&inA[BPS * 1]); 648 const __m128i inA_2 = _mm_loadl_epi64((__m128i*)&inA[BPS * 2]); 649 const __m128i inA_3 = _mm_loadl_epi64((__m128i*)&inA[BPS * 3]); 650 const __m128i inB_0 = _mm_loadl_epi64((__m128i*)&inB[BPS * 0]); 651 const __m128i inB_1 = _mm_loadl_epi64((__m128i*)&inB[BPS * 1]); 652 const __m128i inB_2 = _mm_loadl_epi64((__m128i*)&inB[BPS * 2]); 653 const __m128i inB_3 = _mm_loadl_epi64((__m128i*)&inB[BPS * 3]); 654 655 // Combine inA and inB (we'll do two transforms in parallel). 656 const __m128i inAB_0 = _mm_unpacklo_epi8(inA_0, inB_0); 657 const __m128i inAB_1 = _mm_unpacklo_epi8(inA_1, inB_1); 658 const __m128i inAB_2 = _mm_unpacklo_epi8(inA_2, inB_2); 659 const __m128i inAB_3 = _mm_unpacklo_epi8(inA_3, inB_3); 660 // a00 b00 a01 b01 a02 b03 a03 b03 0 0 0 0 0 0 0 0 661 // a10 b10 a11 b11 a12 b12 a13 b13 0 0 0 0 0 0 0 0 662 // a20 b20 a21 b21 a22 b22 a23 b23 0 0 0 0 0 0 0 0 663 // a30 b30 a31 b31 a32 b32 a33 b33 0 0 0 0 0 0 0 0 664 665 // Transpose the two 4x4, discarding the filling zeroes. 666 const __m128i transpose0_0 = _mm_unpacklo_epi8(inAB_0, inAB_2); 667 const __m128i transpose0_1 = _mm_unpacklo_epi8(inAB_1, inAB_3); 668 // a00 a20 b00 b20 a01 a21 b01 b21 a02 a22 b02 b22 a03 a23 b03 b23 669 // a10 a30 b10 b30 a11 a31 b11 b31 a12 a32 b12 b32 a13 a33 b13 b33 670 const __m128i transpose1_0 = _mm_unpacklo_epi8(transpose0_0, transpose0_1); 671 const __m128i transpose1_1 = _mm_unpackhi_epi8(transpose0_0, transpose0_1); 672 // a00 a10 a20 a30 b00 b10 b20 b30 a01 a11 a21 a31 b01 b11 b21 b31 673 // a02 a12 a22 a32 b02 b12 b22 b32 a03 a13 a23 a33 b03 b13 b23 b33 674 675 // Convert to 16b. 676 tmp_0 = _mm_unpacklo_epi8(transpose1_0, zero); 677 tmp_1 = _mm_unpackhi_epi8(transpose1_0, zero); 678 tmp_2 = _mm_unpacklo_epi8(transpose1_1, zero); 679 tmp_3 = _mm_unpackhi_epi8(transpose1_1, zero); 680 // a00 a10 a20 a30 b00 b10 b20 b30 681 // a01 a11 a21 a31 b01 b11 b21 b31 682 // a02 a12 a22 a32 b02 b12 b22 b32 683 // a03 a13 a23 a33 b03 b13 b23 b33 684 } 685 686 // Horizontal pass and subsequent transpose. 687 { 688 // Calculate a and b (two 4x4 at once). 689 const __m128i a0 = _mm_add_epi16(tmp_0, tmp_2); 690 const __m128i a1 = _mm_add_epi16(tmp_1, tmp_3); 691 const __m128i a2 = _mm_sub_epi16(tmp_1, tmp_3); 692 const __m128i a3 = _mm_sub_epi16(tmp_0, tmp_2); 693 const __m128i b0 = _mm_add_epi16(a0, a1); 694 const __m128i b1 = _mm_add_epi16(a3, a2); 695 const __m128i b2 = _mm_sub_epi16(a3, a2); 696 const __m128i b3 = _mm_sub_epi16(a0, a1); 697 // a00 a01 a02 a03 b00 b01 b02 b03 698 // a10 a11 a12 a13 b10 b11 b12 b13 699 // a20 a21 a22 a23 b20 b21 b22 b23 700 // a30 a31 a32 a33 b30 b31 b32 b33 701 702 // Transpose the two 4x4. 703 const __m128i transpose0_0 = _mm_unpacklo_epi16(b0, b1); 704 const __m128i transpose0_1 = _mm_unpacklo_epi16(b2, b3); 705 const __m128i transpose0_2 = _mm_unpackhi_epi16(b0, b1); 706 const __m128i transpose0_3 = _mm_unpackhi_epi16(b2, b3); 707 // a00 a10 a01 a11 a02 a12 a03 a13 708 // a20 a30 a21 a31 a22 a32 a23 a33 709 // b00 b10 b01 b11 b02 b12 b03 b13 710 // b20 b30 b21 b31 b22 b32 b23 b33 711 const __m128i transpose1_0 = _mm_unpacklo_epi32(transpose0_0, transpose0_1); 712 const __m128i transpose1_1 = _mm_unpacklo_epi32(transpose0_2, transpose0_3); 713 const __m128i transpose1_2 = _mm_unpackhi_epi32(transpose0_0, transpose0_1); 714 const __m128i transpose1_3 = _mm_unpackhi_epi32(transpose0_2, transpose0_3); 715 // a00 a10 a20 a30 a01 a11 a21 a31 716 // b00 b10 b20 b30 b01 b11 b21 b31 717 // a02 a12 a22 a32 a03 a13 a23 a33 718 // b02 b12 a22 b32 b03 b13 b23 b33 719 tmp_0 = _mm_unpacklo_epi64(transpose1_0, transpose1_1); 720 tmp_1 = _mm_unpackhi_epi64(transpose1_0, transpose1_1); 721 tmp_2 = _mm_unpacklo_epi64(transpose1_2, transpose1_3); 722 tmp_3 = _mm_unpackhi_epi64(transpose1_2, transpose1_3); 723 // a00 a10 a20 a30 b00 b10 b20 b30 724 // a01 a11 a21 a31 b01 b11 b21 b31 725 // a02 a12 a22 a32 b02 b12 b22 b32 726 // a03 a13 a23 a33 b03 b13 b23 b33 727 } 728 729 // Vertical pass and difference of weighted sums. 730 { 731 // Load all inputs. 732 // TODO(cduvivier): Make variable declarations and allocations aligned so 733 // we can use _mm_load_si128 instead of _mm_loadu_si128. 734 const __m128i w_0 = _mm_loadu_si128((__m128i*)&w[0]); 735 const __m128i w_8 = _mm_loadu_si128((__m128i*)&w[8]); 736 737 // Calculate a and b (two 4x4 at once). 738 const __m128i a0 = _mm_add_epi16(tmp_0, tmp_2); 739 const __m128i a1 = _mm_add_epi16(tmp_1, tmp_3); 740 const __m128i a2 = _mm_sub_epi16(tmp_1, tmp_3); 741 const __m128i a3 = _mm_sub_epi16(tmp_0, tmp_2); 742 const __m128i b0 = _mm_add_epi16(a0, a1); 743 const __m128i b1 = _mm_add_epi16(a3, a2); 744 const __m128i b2 = _mm_sub_epi16(a3, a2); 745 const __m128i b3 = _mm_sub_epi16(a0, a1); 746 747 // Separate the transforms of inA and inB. 748 __m128i A_b0 = _mm_unpacklo_epi64(b0, b1); 749 __m128i A_b2 = _mm_unpacklo_epi64(b2, b3); 750 __m128i B_b0 = _mm_unpackhi_epi64(b0, b1); 751 __m128i B_b2 = _mm_unpackhi_epi64(b2, b3); 752 753 { 754 // sign(b) = b >> 15 (0x0000 if positive, 0xffff if negative) 755 const __m128i sign_A_b0 = _mm_srai_epi16(A_b0, 15); 756 const __m128i sign_A_b2 = _mm_srai_epi16(A_b2, 15); 757 const __m128i sign_B_b0 = _mm_srai_epi16(B_b0, 15); 758 const __m128i sign_B_b2 = _mm_srai_epi16(B_b2, 15); 759 760 // b = abs(b) = (b ^ sign) - sign 761 A_b0 = _mm_xor_si128(A_b0, sign_A_b0); 762 A_b2 = _mm_xor_si128(A_b2, sign_A_b2); 763 B_b0 = _mm_xor_si128(B_b0, sign_B_b0); 764 B_b2 = _mm_xor_si128(B_b2, sign_B_b2); 765 A_b0 = _mm_sub_epi16(A_b0, sign_A_b0); 766 A_b2 = _mm_sub_epi16(A_b2, sign_A_b2); 767 B_b0 = _mm_sub_epi16(B_b0, sign_B_b0); 768 B_b2 = _mm_sub_epi16(B_b2, sign_B_b2); 769 } 770 771 // weighted sums 772 A_b0 = _mm_madd_epi16(A_b0, w_0); 773 A_b2 = _mm_madd_epi16(A_b2, w_8); 774 B_b0 = _mm_madd_epi16(B_b0, w_0); 775 B_b2 = _mm_madd_epi16(B_b2, w_8); 776 A_b0 = _mm_add_epi32(A_b0, A_b2); 777 B_b0 = _mm_add_epi32(B_b0, B_b2); 778 779 // difference of weighted sums 780 A_b0 = _mm_sub_epi32(A_b0, B_b0); 781 _mm_storeu_si128((__m128i*)&sum[0], A_b0); 782 } 783 return sum[0] + sum[1] + sum[2] + sum[3]; 784} 785 786static int Disto4x4(const uint8_t* const a, const uint8_t* const b, 787 const uint16_t* const w) { 788 const int diff_sum = TTransform(a, b, w); 789 return abs(diff_sum) >> 5; 790} 791 792static int Disto16x16(const uint8_t* const a, const uint8_t* const b, 793 const uint16_t* const w) { 794 int D = 0; 795 int x, y; 796 for (y = 0; y < 16 * BPS; y += 4 * BPS) { 797 for (x = 0; x < 16; x += 4) { 798 D += Disto4x4(a + x + y, b + x + y, w); 799 } 800 } 801 return D; 802} 803 804//------------------------------------------------------------------------------ 805// Quantization 806// 807 808static WEBP_INLINE int DoQuantizeBlock(int16_t in[16], int16_t out[16], 809 const uint16_t* const sharpen, 810 const VP8Matrix* const mtx) { 811 const __m128i max_coeff_2047 = _mm_set1_epi16(MAX_LEVEL); 812 const __m128i zero = _mm_setzero_si128(); 813 __m128i coeff0, coeff8; 814 __m128i out0, out8; 815 __m128i packed_out; 816 817 // Load all inputs. 818 // TODO(cduvivier): Make variable declarations and allocations aligned so that 819 // we can use _mm_load_si128 instead of _mm_loadu_si128. 820 __m128i in0 = _mm_loadu_si128((__m128i*)&in[0]); 821 __m128i in8 = _mm_loadu_si128((__m128i*)&in[8]); 822 const __m128i iq0 = _mm_loadu_si128((__m128i*)&mtx->iq_[0]); 823 const __m128i iq8 = _mm_loadu_si128((__m128i*)&mtx->iq_[8]); 824 const __m128i q0 = _mm_loadu_si128((__m128i*)&mtx->q_[0]); 825 const __m128i q8 = _mm_loadu_si128((__m128i*)&mtx->q_[8]); 826 827 // extract sign(in) (0x0000 if positive, 0xffff if negative) 828 const __m128i sign0 = _mm_cmpgt_epi16(zero, in0); 829 const __m128i sign8 = _mm_cmpgt_epi16(zero, in8); 830 831 // coeff = abs(in) = (in ^ sign) - sign 832 coeff0 = _mm_xor_si128(in0, sign0); 833 coeff8 = _mm_xor_si128(in8, sign8); 834 coeff0 = _mm_sub_epi16(coeff0, sign0); 835 coeff8 = _mm_sub_epi16(coeff8, sign8); 836 837 // coeff = abs(in) + sharpen 838 if (sharpen != NULL) { 839 const __m128i sharpen0 = _mm_loadu_si128((__m128i*)&sharpen[0]); 840 const __m128i sharpen8 = _mm_loadu_si128((__m128i*)&sharpen[8]); 841 coeff0 = _mm_add_epi16(coeff0, sharpen0); 842 coeff8 = _mm_add_epi16(coeff8, sharpen8); 843 } 844 845 // out = (coeff * iQ + B) >> QFIX 846 { 847 // doing calculations with 32b precision (QFIX=17) 848 // out = (coeff * iQ) 849 const __m128i coeff_iQ0H = _mm_mulhi_epu16(coeff0, iq0); 850 const __m128i coeff_iQ0L = _mm_mullo_epi16(coeff0, iq0); 851 const __m128i coeff_iQ8H = _mm_mulhi_epu16(coeff8, iq8); 852 const __m128i coeff_iQ8L = _mm_mullo_epi16(coeff8, iq8); 853 __m128i out_00 = _mm_unpacklo_epi16(coeff_iQ0L, coeff_iQ0H); 854 __m128i out_04 = _mm_unpackhi_epi16(coeff_iQ0L, coeff_iQ0H); 855 __m128i out_08 = _mm_unpacklo_epi16(coeff_iQ8L, coeff_iQ8H); 856 __m128i out_12 = _mm_unpackhi_epi16(coeff_iQ8L, coeff_iQ8H); 857 // out = (coeff * iQ + B) 858 const __m128i bias_00 = _mm_loadu_si128((__m128i*)&mtx->bias_[0]); 859 const __m128i bias_04 = _mm_loadu_si128((__m128i*)&mtx->bias_[4]); 860 const __m128i bias_08 = _mm_loadu_si128((__m128i*)&mtx->bias_[8]); 861 const __m128i bias_12 = _mm_loadu_si128((__m128i*)&mtx->bias_[12]); 862 out_00 = _mm_add_epi32(out_00, bias_00); 863 out_04 = _mm_add_epi32(out_04, bias_04); 864 out_08 = _mm_add_epi32(out_08, bias_08); 865 out_12 = _mm_add_epi32(out_12, bias_12); 866 // out = QUANTDIV(coeff, iQ, B, QFIX) 867 out_00 = _mm_srai_epi32(out_00, QFIX); 868 out_04 = _mm_srai_epi32(out_04, QFIX); 869 out_08 = _mm_srai_epi32(out_08, QFIX); 870 out_12 = _mm_srai_epi32(out_12, QFIX); 871 872 // pack result as 16b 873 out0 = _mm_packs_epi32(out_00, out_04); 874 out8 = _mm_packs_epi32(out_08, out_12); 875 876 // if (coeff > 2047) coeff = 2047 877 out0 = _mm_min_epi16(out0, max_coeff_2047); 878 out8 = _mm_min_epi16(out8, max_coeff_2047); 879 } 880 881 // get sign back (if (sign[j]) out_n = -out_n) 882 out0 = _mm_xor_si128(out0, sign0); 883 out8 = _mm_xor_si128(out8, sign8); 884 out0 = _mm_sub_epi16(out0, sign0); 885 out8 = _mm_sub_epi16(out8, sign8); 886 887 // in = out * Q 888 in0 = _mm_mullo_epi16(out0, q0); 889 in8 = _mm_mullo_epi16(out8, q8); 890 891 _mm_storeu_si128((__m128i*)&in[0], in0); 892 _mm_storeu_si128((__m128i*)&in[8], in8); 893 894 // zigzag the output before storing it. 895 // 896 // The zigzag pattern can almost be reproduced with a small sequence of 897 // shuffles. After it, we only need to swap the 7th (ending up in third 898 // position instead of twelfth) and 8th values. 899 { 900 __m128i outZ0, outZ8; 901 outZ0 = _mm_shufflehi_epi16(out0, _MM_SHUFFLE(2, 1, 3, 0)); 902 outZ0 = _mm_shuffle_epi32 (outZ0, _MM_SHUFFLE(3, 1, 2, 0)); 903 outZ0 = _mm_shufflehi_epi16(outZ0, _MM_SHUFFLE(3, 1, 0, 2)); 904 outZ8 = _mm_shufflelo_epi16(out8, _MM_SHUFFLE(3, 0, 2, 1)); 905 outZ8 = _mm_shuffle_epi32 (outZ8, _MM_SHUFFLE(3, 1, 2, 0)); 906 outZ8 = _mm_shufflelo_epi16(outZ8, _MM_SHUFFLE(1, 3, 2, 0)); 907 _mm_storeu_si128((__m128i*)&out[0], outZ0); 908 _mm_storeu_si128((__m128i*)&out[8], outZ8); 909 packed_out = _mm_packs_epi16(outZ0, outZ8); 910 } 911 { 912 const int16_t outZ_12 = out[12]; 913 const int16_t outZ_3 = out[3]; 914 out[3] = outZ_12; 915 out[12] = outZ_3; 916 } 917 918 // detect if all 'out' values are zeroes or not 919 return (_mm_movemask_epi8(_mm_cmpeq_epi8(packed_out, zero)) != 0xffff); 920} 921 922static int QuantizeBlock(int16_t in[16], int16_t out[16], 923 const VP8Matrix* const mtx) { 924 return DoQuantizeBlock(in, out, &mtx->sharpen_[0], mtx); 925} 926 927static int QuantizeBlockWHT(int16_t in[16], int16_t out[16], 928 const VP8Matrix* const mtx) { 929 return DoQuantizeBlock(in, out, NULL, mtx); 930} 931 932// Forward declaration. 933void VP8SetResidualCoeffsSSE2(const int16_t* const coeffs, 934 VP8Residual* const res); 935 936void VP8SetResidualCoeffsSSE2(const int16_t* const coeffs, 937 VP8Residual* const res) { 938 const __m128i c0 = _mm_loadu_si128((const __m128i*)coeffs); 939 const __m128i c1 = _mm_loadu_si128((const __m128i*)(coeffs + 8)); 940 // Use SSE to compare 8 values with a single instruction. 941 const __m128i zero = _mm_setzero_si128(); 942 const __m128i m0 = _mm_cmpeq_epi16(c0, zero); 943 const __m128i m1 = _mm_cmpeq_epi16(c1, zero); 944 // Get the comparison results as a bitmask, consisting of two times 16 bits: 945 // two identical bits for each result. Concatenate both bitmasks to get a 946 // single 32 bit value. Negate the mask to get the position of entries that 947 // are not equal to zero. We don't need to mask out least significant bits 948 // according to res->first, since coeffs[0] is 0 if res->first > 0 949 const uint32_t mask = 950 ~(((uint32_t)_mm_movemask_epi8(m1) << 16) | _mm_movemask_epi8(m0)); 951 // The position of the most significant non-zero bit indicates the position of 952 // the last non-zero value. Divide the result by two because __movemask_epi8 953 // operates on 8 bit values instead of 16 bit values. 954 assert(res->first == 0 || coeffs[0] == 0); 955 res->last = mask ? (BitsLog2Floor(mask) >> 1) : -1; 956 res->coeffs = coeffs; 957} 958 959#endif // WEBP_USE_SSE2 960 961//------------------------------------------------------------------------------ 962// Entry point 963 964extern void VP8EncDspInitSSE2(void); 965 966void VP8EncDspInitSSE2(void) { 967#if defined(WEBP_USE_SSE2) 968 VP8CollectHistogram = CollectHistogram; 969 VP8EncQuantizeBlock = QuantizeBlock; 970 VP8EncQuantizeBlockWHT = QuantizeBlockWHT; 971 VP8ITransform = ITransform; 972 VP8FTransform = FTransform; 973 VP8FTransformWHT = FTransformWHT; 974 VP8SSE16x16 = SSE16x16; 975 VP8SSE16x8 = SSE16x8; 976 VP8SSE8x8 = SSE8x8; 977 VP8SSE4x4 = SSE4x4; 978 VP8TDisto4x4 = Disto4x4; 979 VP8TDisto16x16 = Disto16x16; 980#endif // WEBP_USE_SSE2 981} 982 983