Update libwebp to 0.4.0

third_party/libwebp/dsp/enc_sse2.c

 // Copyright 2011 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 version of speed-critical encoding functions.
 //
 // Author: Christian Duvivier (cduvivier@google.com)
 
 #include "./dsp.h"
 
-#if defined(__cplusplus) || defined(c_plusplus)
-extern "C" {
-#endif
-
 #if defined(WEBP_USE_SSE2)
 #include <stdlib.h>  // for abs()
 #include <emmintrin.h>
 
 #include "../enc/vp8enci.h"
 
 //------------------------------------------------------------------------------
 // Quite useful macro for debugging. Left here for convenience.
 
 #if 0
@@ skipping 419 matching lines @@
     const __m128i g1 = _mm_add_epi16(f1, _mm_cmpeq_epi16(a32, zero));
 
     _mm_storel_epi64((__m128i*)&out[ 0], d0);
     _mm_storel_epi64((__m128i*)&out[ 4], g1);
     _mm_storel_epi64((__m128i*)&out[ 8], d2);
     _mm_storel_epi64((__m128i*)&out[12], f3);
   }
 }
 
 static void FTransformWHTSSE2(const int16_t* in, int16_t* out) {
-  int16_t tmp[16];
+  int32_t tmp[16];
   int i;
   for (i = 0; i < 4; ++i, in += 64) {
     const int a0 = (in[0 * 16] + in[2 * 16]);
     const int a1 = (in[1 * 16] + in[3 * 16]);
     const int a2 = (in[1 * 16] - in[3 * 16]);
     const int a3 = (in[0 * 16] - in[2 * 16]);
     tmp[0 + i * 4] = a0 + a1;
     tmp[1 + i * 4] = a3 + a2;
     tmp[2 + i * 4] = a3 - a2;
     tmp[3 + i * 4] = a0 - a1;
   }
   {
-    const __m128i src0 = _mm_loadl_epi64((__m128i*)&tmp[0]);
-    const __m128i src1 = _mm_loadl_epi64((__m128i*)&tmp[4]);
-    const __m128i src2 = _mm_loadl_epi64((__m128i*)&tmp[8]);
-    const __m128i src3 = _mm_loadl_epi64((__m128i*)&tmp[12]);
-    const __m128i a0 = _mm_add_epi16(src0, src2);
-    const __m128i a1 = _mm_add_epi16(src1, src3);
-    const __m128i a2 = _mm_sub_epi16(src1, src3);
-    const __m128i a3 = _mm_sub_epi16(src0, src2);
-    const __m128i b0 = _mm_srai_epi16(_mm_adds_epi16(a0, a1), 1);
-    const __m128i b1 = _mm_srai_epi16(_mm_adds_epi16(a3, a2), 1);
-    const __m128i b2 = _mm_srai_epi16(_mm_subs_epi16(a3, a2), 1);
-    const __m128i b3 = _mm_srai_epi16(_mm_subs_epi16(a0, a1), 1);
-    _mm_storel_epi64((__m128i*)&out[ 0], b0);
-    _mm_storel_epi64((__m128i*)&out[ 4], b1);
-    _mm_storel_epi64((__m128i*)&out[ 8], b2);
-    _mm_storel_epi64((__m128i*)&out[12], b3);
+    const __m128i src0 = _mm_loadu_si128((__m128i*)&tmp[0]);
+    const __m128i src1 = _mm_loadu_si128((__m128i*)&tmp[4]);
+    const __m128i src2 = _mm_loadu_si128((__m128i*)&tmp[8]);
+    const __m128i src3 = _mm_loadu_si128((__m128i*)&tmp[12]);
+    const __m128i a0 = _mm_add_epi32(src0, src2);
+    const __m128i a1 = _mm_add_epi32(src1, src3);
+    const __m128i a2 = _mm_sub_epi32(src1, src3);
+    const __m128i a3 = _mm_sub_epi32(src0, src2);
+    const __m128i b0 = _mm_srai_epi32(_mm_add_epi32(a0, a1), 1);
+    const __m128i b1 = _mm_srai_epi32(_mm_add_epi32(a3, a2), 1);
+    const __m128i b2 = _mm_srai_epi32(_mm_sub_epi32(a3, a2), 1);
+    const __m128i b3 = _mm_srai_epi32(_mm_sub_epi32(a0, a1), 1);
+    const __m128i out0 = _mm_packs_epi32(b0, b1);
+    const __m128i out1 = _mm_packs_epi32(b2, b3);
+    _mm_storeu_si128((__m128i*)&out[0], out0);
+    _mm_storeu_si128((__m128i*)&out[8], out1);
   }
 }
 
 //------------------------------------------------------------------------------
 // Metric
 
 static int SSE_Nx4SSE2(const uint8_t* a, const uint8_t* b,
                        int num_quads, int do_16) {
   const __m128i zero = _mm_setzero_si128();
   __m128i sum1 = zero;
@@ skipping 139 matching lines @@
 
 // Hadamard transform
 // Returns the difference between the weighted sum of the absolute value of
 // transformed coefficients.
 static int TTransformSSE2(const uint8_t* inA, const uint8_t* inB,
                           const uint16_t* const w) {
   int32_t sum[4];
   __m128i tmp_0, tmp_1, tmp_2, tmp_3;
   const __m128i zero = _mm_setzero_si128();
 
-  // Load, combine and tranpose inputs.
+  // Load, combine and transpose inputs.
   {
     const __m128i inA_0 = _mm_loadl_epi64((__m128i*)&inA[BPS * 0]);
     const __m128i inA_1 = _mm_loadl_epi64((__m128i*)&inA[BPS * 1]);
     const __m128i inA_2 = _mm_loadl_epi64((__m128i*)&inA[BPS * 2]);
     const __m128i inA_3 = _mm_loadl_epi64((__m128i*)&inA[BPS * 3]);
     const __m128i inB_0 = _mm_loadl_epi64((__m128i*)&inB[BPS * 0]);
     const __m128i inB_1 = _mm_loadl_epi64((__m128i*)&inB[BPS * 1]);
     const __m128i inB_2 = _mm_loadl_epi64((__m128i*)&inB[BPS * 2]);
     const __m128i inB_3 = _mm_loadl_epi64((__m128i*)&inB[BPS * 3]);
 
@@ skipping 165 matching lines @@
   __m128i in0 = _mm_loadu_si128((__m128i*)&in[0]);
   __m128i in8 = _mm_loadu_si128((__m128i*)&in[8]);
   const __m128i sharpen0 = _mm_loadu_si128((__m128i*)&mtx->sharpen_[0]);
   const __m128i sharpen8 = _mm_loadu_si128((__m128i*)&mtx->sharpen_[8]);
   const __m128i iq0 = _mm_loadu_si128((__m128i*)&mtx->iq_[0]);
   const __m128i iq8 = _mm_loadu_si128((__m128i*)&mtx->iq_[8]);
   const __m128i bias0 = _mm_loadu_si128((__m128i*)&mtx->bias_[0]);
   const __m128i bias8 = _mm_loadu_si128((__m128i*)&mtx->bias_[8]);
   const __m128i q0 = _mm_loadu_si128((__m128i*)&mtx->q_[0]);
   const __m128i q8 = _mm_loadu_si128((__m128i*)&mtx->q_[8]);
-  const __m128i zthresh0 = _mm_loadu_si128((__m128i*)&mtx->zthresh_[0]);
-  const __m128i zthresh8 = _mm_loadu_si128((__m128i*)&mtx->zthresh_[8]);
 
   // sign(in) = in >> 15  (0x0000 if positive, 0xffff if negative)
   const __m128i sign0 = _mm_srai_epi16(in0, 15);
   const __m128i sign8 = _mm_srai_epi16(in8, 15);
 
   // coeff = abs(in) = (in ^ sign) - sign
   coeff0 = _mm_xor_si128(in0, sign0);
   coeff8 = _mm_xor_si128(in8, sign8);
   coeff0 = _mm_sub_epi16(coeff0, sign0);
   coeff8 = _mm_sub_epi16(coeff8, sign8);
@@ skipping 42 matching lines @@
   // get sign back (if (sign[j]) out_n = -out_n)
   out0 = _mm_xor_si128(out0, sign0);
   out8 = _mm_xor_si128(out8, sign8);
   out0 = _mm_sub_epi16(out0, sign0);
   out8 = _mm_sub_epi16(out8, sign8);
 
   // in = out * Q
   in0 = _mm_mullo_epi16(out0, q0);
   in8 = _mm_mullo_epi16(out8, q8);
 
-  // if (coeff <= mtx->zthresh_) {in=0; out=0;}
-  {
-    __m128i cmp0 = _mm_cmpgt_epi16(coeff0, zthresh0);
-    __m128i cmp8 = _mm_cmpgt_epi16(coeff8, zthresh8);
-    in0 = _mm_and_si128(in0, cmp0);
-    in8 = _mm_and_si128(in8, cmp8);
-    _mm_storeu_si128((__m128i*)&in[0], in0);
-    _mm_storeu_si128((__m128i*)&in[8], in8);
-    out0 = _mm_and_si128(out0, cmp0);
-    out8 = _mm_and_si128(out8, cmp8);
-  }
+  _mm_storeu_si128((__m128i*)&in[0], in0);
+  _mm_storeu_si128((__m128i*)&in[8], in8);
 
   // zigzag the output before storing it.
   //
   // The zigzag pattern can almost be reproduced with a small sequence of
   // shuffles. After it, we only need to swap the 7th (ending up in third
   // position instead of twelfth) and 8th values.
   {
     __m128i outZ0, outZ8;
     outZ0 = _mm_shufflehi_epi16(out0,  _MM_SHUFFLE(2, 1, 3, 0));
     outZ0 = _mm_shuffle_epi32  (outZ0, _MM_SHUFFLE(3, 1, 2, 0));
@@ skipping 16 matching lines @@
   {
     int32_t tmp[4];
     _mm_storeu_si128((__m128i*)tmp, packed_out);
     if (n) {
       tmp[0] &= ~0xff;
     }
     return (tmp[3] || tmp[2] || tmp[1] || tmp[0]);
   }
 }
 
+static int QuantizeBlockWHTSSE2(int16_t in[16], int16_t out[16],
+                                const VP8Matrix* const mtx) {
+  return QuantizeBlockSSE2(in, out, 0, mtx);
+}
+
 #endif   // WEBP_USE_SSE2
 
 //------------------------------------------------------------------------------
 // Entry point
 
 extern void VP8EncDspInitSSE2(void);
 
 void VP8EncDspInitSSE2(void) {
 #if defined(WEBP_USE_SSE2)
   VP8CollectHistogram = CollectHistogramSSE2;
   VP8EncQuantizeBlock = QuantizeBlockSSE2;
+  VP8EncQuantizeBlockWHT = QuantizeBlockWHTSSE2;
   VP8ITransform = ITransformSSE2;
   VP8FTransform = FTransformSSE2;
   VP8FTransformWHT = FTransformWHTSSE2;
   VP8SSE16x16 = SSE16x16SSE2;
   VP8SSE16x8 = SSE16x8SSE2;
   VP8SSE8x8 = SSE8x8SSE2;
   VP8SSE4x4 = SSE4x4SSE2;
   VP8TDisto4x4 = Disto4x4SSE2;
   VP8TDisto16x16 = Disto16x16SSE2;
 #endif   // WEBP_USE_SSE2
 }
 
-#if defined(__cplusplus) || defined(c_plusplus)
-}    // extern "C"
-#endif