libwebp: update snapshot to v0.3.0-rc6

third_party/libwebp/dsp/dec_sse2.c

 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // This code is licensed under the same terms as WebM:
 //  Software License Agreement:  http://www.webmproject.org/license/software/
 //  Additional IP Rights Grant:  http://www.webmproject.org/license/additional/
 // -----------------------------------------------------------------------------
 //
 // SSE2 version of some decoding functions (idct, loop filtering).
 //
 // Author: somnath@google.com (Somnath Banerjee)
 //         cduvivier@google.com (Christian Duvivier)
 
 #include "./dsp.h"
 
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
 #if defined(WEBP_USE_SSE2)
 
 #include <emmintrin.h>
 #include "../dec/vp8i.h"
 
-#if defined(__cplusplus) || defined(c_plusplus)
-extern "C" {
-#endif
-
 //------------------------------------------------------------------------------
 // Transforms (Paragraph 14.4)
 
 static void TransformSSE2(const int16_t* in, uint8_t* dst, int do_two) {
   // This implementation makes use of 16-bit fixed point versions of two
   // multiply constants:
   //    K1 = sqrt(2) * cos (pi/8) ~= 85627 / 2^16
   //    K2 = sqrt(2) * sin (pi/8) ~= 35468 / 2^16
   //
   // To be able to use signed 16-bit integers, we use the following trick to
@@ skipping 153 matching lines @@
     T2 = _mm_unpacklo_epi64(transpose1_2, transpose1_3);
     T3 = _mm_unpackhi_epi64(transpose1_2, transpose1_3);
     // a00 a10 a20 a30   b00 b10 b20 b30
     // a01 a11 a21 a31   b01 b11 b21 b31
     // a02 a12 a22 a32   b02 b12 b22 b32
     // a03 a13 a23 a33   b03 b13 b23 b33
   }
 
   // Add inverse transform to 'dst' and store.
   {
-    const __m128i zero = _mm_set1_epi16(0);
+    const __m128i zero = _mm_setzero_si128();
     // Load the reference(s).
     __m128i dst0, dst1, dst2, dst3;
     if (do_two) {
       // Load eight bytes/pixels per line.
       dst0 = _mm_loadl_epi64((__m128i*)&dst[0 * BPS]);
       dst1 = _mm_loadl_epi64((__m128i*)&dst[1 * BPS]);
       dst2 = _mm_loadl_epi64((__m128i*)&dst[2 * BPS]);
       dst3 = _mm_loadl_epi64((__m128i*)&dst[3 * BPS]);
     } else {
       // Load four bytes/pixels per line.
@@ skipping 63 matching lines @@
   b = _mm_xor_si128(b, sign_bit);                                              \
 }
 
 #define FLIP_SIGN_BIT4(a, b, c, d) {                                           \
   FLIP_SIGN_BIT2(a, b);                                                        \
   FLIP_SIGN_BIT2(c, d);                                                        \
 }
 
 #define GET_NOTHEV(p1, p0, q0, q1, hev_thresh, not_hev) {                      \
   const __m128i zero = _mm_setzero_si128();                                    \
-  const __m128i t1 = MM_ABS(p1, p0);                                           \
-  const __m128i t2 = MM_ABS(q1, q0);                                           \
+  const __m128i t_1 = MM_ABS(p1, p0);                                          \
+  const __m128i t_2 = MM_ABS(q1, q0);                                          \
                                                                                \
   const __m128i h = _mm_set1_epi8(hev_thresh);                                 \
-  const __m128i t3 = _mm_subs_epu8(t1, h);  /* abs(p1 - p0) - hev_tresh */     \
-  const __m128i t4 = _mm_subs_epu8(t2, h);  /* abs(q1 - q0) - hev_tresh */     \
+  const __m128i t_3 = _mm_subs_epu8(t_1, h);  /* abs(p1 - p0) - hev_tresh */   \
+  const __m128i t_4 = _mm_subs_epu8(t_2, h);  /* abs(q1 - q0) - hev_tresh */   \
                                                                                \
-  not_hev = _mm_or_si128(t3, t4);                                              \
+  not_hev = _mm_or_si128(t_3, t_4);                                            \
   not_hev = _mm_cmpeq_epi8(not_hev, zero); /* not_hev <= t1 && not_hev <= t2 */\
 }
 
 #define GET_BASE_DELTA(p1, p0, q0, q1, o) {                                    \
   const __m128i qp0 = _mm_subs_epi8(q0, p0);  /* q0 - p0 */                    \
   o = _mm_subs_epi8(p1, q1);            /* p1 - q1 */                          \
   o = _mm_adds_epi8(o, qp0);            /* p1 - q1 + 1 * (q0 - p0) */          \
   o = _mm_adds_epi8(o, qp0);            /* p1 - q1 + 2 * (q0 - p0) */          \
   o = _mm_adds_epi8(o, qp0);            /* p1 - q1 + 3 * (q0 - p0) */          \
 }
 
 #define DO_SIMPLE_FILTER(p0, q0, fl) {                                         \
   const __m128i three = _mm_set1_epi8(3);                                      \
   const __m128i four = _mm_set1_epi8(4);                                       \
   __m128i v3 = _mm_adds_epi8(fl, three);                                       \
   __m128i v4 = _mm_adds_epi8(fl, four);                                        \
                                                                                \
   /* Do +4 side */                                                             \
   SIGNED_SHIFT_N(v4, 3);                /* v4 >> 3  */                         \
   q0 = _mm_subs_epi8(q0, v4);           /* q0 -= v4 */                         \
                                                                                \
   /* Now do +3 side */                                                         \
   SIGNED_SHIFT_N(v3, 3);                /* v3 >> 3  */                         \
   p0 = _mm_adds_epi8(p0, v3);           /* p0 += v3 */                         \
 }
 
 // Updates values of 2 pixels at MB edge during complex filtering.
 // Update operations:
-// q = q - a and p = p + a; where a = [(a_hi >> 7), (a_lo >> 7)]
+// q = q - delta and p = p + delta; where delta = [(a_hi >> 7), (a_lo >> 7)]
 #define UPDATE_2PIXELS(pi, qi, a_lo, a_hi) {                                   \
   const __m128i a_lo7 = _mm_srai_epi16(a_lo, 7);                               \
   const __m128i a_hi7 = _mm_srai_epi16(a_hi, 7);                               \
-  const __m128i a = _mm_packs_epi16(a_lo7, a_hi7);                             \
-  pi = _mm_adds_epi8(pi, a);                                                   \
-  qi = _mm_subs_epi8(qi, a);                                                   \
+  const __m128i delta = _mm_packs_epi16(a_lo7, a_hi7);                         \
+  pi = _mm_adds_epi8(pi, delta);                                               \
+  qi = _mm_subs_epi8(qi, delta);                                               \
 }
 
 static void NeedsFilter(const __m128i* p1, const __m128i* p0, const __m128i* q0,
                         const __m128i* q1, int thresh, __m128i *mask) {
   __m128i t1 = MM_ABS(*p1, *q1);        // abs(p1 - q1)
   *mask = _mm_set1_epi8(0xFE);
   t1 = _mm_and_si128(t1, *mask);        // set lsb of each byte to zero
   t1 = _mm_srli_epi16(t1, 1);           // abs(p1 - q1) / 2
 
   *mask = MM_ABS(*p0, *q0);             // abs(p0 - q0)
@@ skipping 535 matching lines @@
   MAX_DIFF2(t2, t1, q1, q0, mask);
 
   COMPLEX_FL_MASK(p1, p0, q0, q1, thresh, ithresh, mask);
   DoFilter4(&p1, &p0, &q0, &q1, &mask, hev_thresh);
 
   u -= 2;  // beginning of p1
   v -= 2;
   Store16x4(u, v, stride, &p1, &p0, &q0, &q1);
 }
 
+#endif   // WEBP_USE_SSE2
+
+//------------------------------------------------------------------------------
+// Entry point
+
 extern void VP8DspInitSSE2(void);
 
 void VP8DspInitSSE2(void) {
+#if defined(WEBP_USE_SSE2)
   VP8Transform = TransformSSE2;
 
   VP8VFilter16 = VFilter16SSE2;
   VP8HFilter16 = HFilter16SSE2;
   VP8VFilter8 = VFilter8SSE2;
   VP8HFilter8 = HFilter8SSE2;
   VP8VFilter16i = VFilter16iSSE2;
   VP8HFilter16i = HFilter16iSSE2;
   VP8VFilter8i = VFilter8iSSE2;
   VP8HFilter8i = HFilter8iSSE2;
 
   VP8SimpleVFilter16 = SimpleVFilter16SSE2;
   VP8SimpleHFilter16 = SimpleHFilter16SSE2;
   VP8SimpleVFilter16i = SimpleVFilter16iSSE2;
   VP8SimpleHFilter16i = SimpleHFilter16iSSE2;
+#endif   // WEBP_USE_SSE2
 }
 
 #if defined(__cplusplus) || defined(c_plusplus)
 }    // extern "C"
 #endif
-
-#endif   // WEBP_USE_SSE2