libvpx: Pull from upstream

source/libvpx/vp9/encoder/x86/vp9_dct_avx2.c

 /*
  *  Copyright (c) 2012 The WebM project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE 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.
  */
 
 #include <immintrin.h>  // AVX2
 #include "vp9/common/vp9_idct.h"  // for cospi constants
 #include "vpx_ports/mem.h"
 
 void vp9_fdct4x4_avx2(const int16_t *input, int16_t *output, int stride) {
   // The 2D transform is done with two passes which are actually pretty
   // similar. In the first one, we transform the columns and transpose
   // the results. In the second one, we transform the rows. To achieve that,
-  // as the first pass results are transposed, we tranpose the columns (that
+  // as the first pass results are transposed, we transpose the columns (that
   // is the transposed rows) and transpose the results (so that it goes back
   // in normal/row positions).
   int pass;
   // Constants
   //    When we use them, in one case, they are all the same. In all others
   //    it's a pair of them that we need to repeat four times. This is done
   //    by constructing the 32 bit constant corresponding to that pair.
   const __m128i k__cospi_p16_p16 = _mm_set1_epi16(cospi_16_64);
   const __m128i k__cospi_p16_m16 = pair_set_epi16(cospi_16_64, -cospi_16_64);
   const __m128i k__cospi_p24_p08 = pair_set_epi16(cospi_24_64, cospi_8_64);
   const __m128i k__cospi_m08_p24 = pair_set_epi16(-cospi_8_64, cospi_24_64);
   const __m128i k__DCT_CONST_ROUNDING = _mm_set1_epi32(DCT_CONST_ROUNDING);
   const __m128i k__nonzero_bias_a = _mm_setr_epi16(0, 1, 1, 1, 1, 1, 1, 1);
   const __m128i k__nonzero_bias_b = _mm_setr_epi16(1, 0, 0, 0, 0, 0, 0, 0);
   const __m128i kOne = _mm_set1_epi16(1);
   __m128i in0, in1, in2, in3;
   // Load inputs.
   {
     in0  = _mm_loadl_epi64((const __m128i *)(input +  0 * stride));
     in1  = _mm_loadl_epi64((const __m128i *)(input +  1 * stride));
     in2  = _mm_loadl_epi64((const __m128i *)(input +  2 * stride));
     in3  = _mm_loadl_epi64((const __m128i *)(input +  3 * stride));
     // x = x << 4
     in0 = _mm_slli_epi16(in0, 4);
     in1 = _mm_slli_epi16(in1, 4);
     in2 = _mm_slli_epi16(in2, 4);
     in3 = _mm_slli_epi16(in3, 4);
     // if (i == 0 && input[0]) input[0] += 1;
     {
-      // The mask will only contain wether the first value is zero, all
+      // The mask will only contain whether the first value is zero, all
       // other comparison will fail as something shifted by 4 (above << 4)
       // can never be equal to one. To increment in the non-zero case, we
       // add the mask and one for the first element:
       //   - if zero, mask = -1, v = v - 1 + 1 = v
       //   - if non-zero, mask = 0, v = v + 0 + 1 = v + 1
       __m128i mask = _mm_cmpeq_epi16(in0, k__nonzero_bias_a);
       in0 = _mm_add_epi16(in0, mask);
       in0 = _mm_add_epi16(in0, k__nonzero_bias_b);
     }
   }
   // Do the two transform/transpose passes
   for (pass = 0; pass < 2; ++pass) {
-    // Transform 1/2: Add/substract
+    // Transform 1/2: Add/subtract
     const __m128i r0 = _mm_add_epi16(in0, in3);
     const __m128i r1 = _mm_add_epi16(in1, in2);
     const __m128i r2 = _mm_sub_epi16(in1, in2);
     const __m128i r3 = _mm_sub_epi16(in0, in3);
     // Transform 1/2: Interleave to do the multiply by constants which gets us
     //                into 32 bits.
     const __m128i t0 = _mm_unpacklo_epi16(r0, r1);
     const __m128i t2 = _mm_unpacklo_epi16(r2, r3);
     const __m128i u0 = _mm_madd_epi16(t0, k__cospi_p16_p16);
     const __m128i u2 = _mm_madd_epi16(t0, k__cospi_p16_m16);
@@ skipping 237 matching lines @@
   in6 = _mm_slli_epi16(in6, 2);
   in7 = _mm_slli_epi16(in7, 2);
 
   // We do two passes, first the columns, then the rows. The results of the
   // first pass are transposed so that the same column code can be reused. The
   // results of the second pass are also transposed so that the rows (processed
   // as columns) are put back in row positions.
   for (pass = 0; pass < 2; pass++) {
     // To store results of each pass before the transpose.
     __m128i res0, res1, res2, res3, res4, res5, res6, res7;
-    // Add/substract
+    // Add/subtract
     const __m128i q0 = _mm_add_epi16(in0, in7);
     const __m128i q1 = _mm_add_epi16(in1, in6);
     const __m128i q2 = _mm_add_epi16(in2, in5);
     const __m128i q3 = _mm_add_epi16(in3, in4);
     const __m128i q4 = _mm_sub_epi16(in3, in4);
     const __m128i q5 = _mm_sub_epi16(in2, in5);
     const __m128i q6 = _mm_sub_epi16(in1, in6);
     const __m128i q7 = _mm_sub_epi16(in0, in7);
     // Work on first four results
     {
-      // Add/substract
+      // Add/subtract
       const __m128i r0 = _mm_add_epi16(q0, q3);
       const __m128i r1 = _mm_add_epi16(q1, q2);
       const __m128i r2 = _mm_sub_epi16(q1, q2);
       const __m128i r3 = _mm_sub_epi16(q0, q3);
       // Interleave to do the multiply by constants which gets us into 32bits
       const __m128i t0 = _mm_unpacklo_epi16(r0, r1);
       const __m128i t1 = _mm_unpackhi_epi16(r0, r1);
       const __m128i t2 = _mm_unpacklo_epi16(r2, r3);
       const __m128i t3 = _mm_unpackhi_epi16(r2, r3);
       const __m128i u0 = _mm_madd_epi16(t0, k__cospi_p16_p16);
@@ skipping 41 matching lines @@
       const __m128i f1 = _mm_add_epi32(e1, k__DCT_CONST_ROUNDING);
       const __m128i f2 = _mm_add_epi32(e2, k__DCT_CONST_ROUNDING);
       const __m128i f3 = _mm_add_epi32(e3, k__DCT_CONST_ROUNDING);
       const __m128i s0 = _mm_srai_epi32(f0, DCT_CONST_BITS);
       const __m128i s1 = _mm_srai_epi32(f1, DCT_CONST_BITS);
       const __m128i s2 = _mm_srai_epi32(f2, DCT_CONST_BITS);
       const __m128i s3 = _mm_srai_epi32(f3, DCT_CONST_BITS);
       // Combine
       const __m128i r0 = _mm_packs_epi32(s0, s1);
       const __m128i r1 = _mm_packs_epi32(s2, s3);
-      // Add/substract
+      // Add/subtract
       const __m128i x0 = _mm_add_epi16(q4, r0);
       const __m128i x1 = _mm_sub_epi16(q4, r0);
       const __m128i x2 = _mm_sub_epi16(q7, r1);
       const __m128i x3 = _mm_add_epi16(q7, r1);
       // Interleave to do the multiply by constants which gets us into 32bits
       const __m128i t0 = _mm_unpacklo_epi16(x0, x3);
       const __m128i t1 = _mm_unpackhi_epi16(x0, x3);
       const __m128i t2 = _mm_unpacklo_epi16(x1, x2);
       const __m128i t3 = _mm_unpackhi_epi16(x1, x2);
       const __m128i u0 = _mm_madd_epi16(t0, k__cospi_p28_p04);
@@ skipping 660 matching lines @@
     default:
       assert(0);
       break;
   }
 }
 
 void vp9_fdct16x16_avx2(const int16_t *input, int16_t *output, int stride) {
   // The 2D transform is done with two passes which are actually pretty
   // similar. In the first one, we transform the columns and transpose
   // the results. In the second one, we transform the rows. To achieve that,
-  // as the first pass results are transposed, we tranpose the columns (that
+  // as the first pass results are transposed, we transpose the columns (that
   // is the transposed rows) and transpose the results (so that it goes back
   // in normal/row positions).
   int pass;
   // We need an intermediate buffer between passes.
   DECLARE_ALIGNED_ARRAY(16, int16_t, intermediate, 256);
   const int16_t *in = input;
   int16_t *out = intermediate;
   // Constants
   //    When we use them, in one case, they are all the same. In all others
   //    it's a pair of them that we need to repeat four times. This is done
@@ skipping 136 matching lines @@
         step1_1 = _mm_sub_epi16(in06, in09);
         step1_2 = _mm_sub_epi16(in05, in10);
         step1_3 = _mm_sub_epi16(in04, in11);
         step1_4 = _mm_sub_epi16(in03, in12);
         step1_5 = _mm_sub_epi16(in02, in13);
         step1_6 = _mm_sub_epi16(in01, in14);
         step1_7 = _mm_sub_epi16(in00, in15);
       }
       // Work on the first eight values; fdct8(input, even_results);
       {
-        // Add/substract
+        // Add/subtract
         const __m128i q0 = _mm_add_epi16(input0, input7);
         const __m128i q1 = _mm_add_epi16(input1, input6);
         const __m128i q2 = _mm_add_epi16(input2, input5);
         const __m128i q3 = _mm_add_epi16(input3, input4);
         const __m128i q4 = _mm_sub_epi16(input3, input4);
         const __m128i q5 = _mm_sub_epi16(input2, input5);
         const __m128i q6 = _mm_sub_epi16(input1, input6);
         const __m128i q7 = _mm_sub_epi16(input0, input7);
         // Work on first four results
         {
-          // Add/substract
+          // Add/subtract
           const __m128i r0 = _mm_add_epi16(q0, q3);
           const __m128i r1 = _mm_add_epi16(q1, q2);
           const __m128i r2 = _mm_sub_epi16(q1, q2);
           const __m128i r3 = _mm_sub_epi16(q0, q3);
           // Interleave to do the multiply by constants which gets us
           // into 32 bits.
           const __m128i t0 = _mm_unpacklo_epi16(r0, r1);
           const __m128i t1 = _mm_unpackhi_epi16(r0, r1);
           const __m128i t2 = _mm_unpacklo_epi16(r2, r3);
           const __m128i t3 = _mm_unpackhi_epi16(r2, r3);
@@ skipping 43 matching lines @@
           const __m128i f1 = _mm_add_epi32(e1, k__DCT_CONST_ROUNDING);
           const __m128i f2 = _mm_add_epi32(e2, k__DCT_CONST_ROUNDING);
           const __m128i f3 = _mm_add_epi32(e3, k__DCT_CONST_ROUNDING);
           const __m128i s0 = _mm_srai_epi32(f0, DCT_CONST_BITS);
           const __m128i s1 = _mm_srai_epi32(f1, DCT_CONST_BITS);
           const __m128i s2 = _mm_srai_epi32(f2, DCT_CONST_BITS);
           const __m128i s3 = _mm_srai_epi32(f3, DCT_CONST_BITS);
           // Combine
           const __m128i r0 = _mm_packs_epi32(s0, s1);
           const __m128i r1 = _mm_packs_epi32(s2, s3);
-          // Add/substract
+          // Add/subtract
           const __m128i x0 = _mm_add_epi16(q4, r0);
           const __m128i x1 = _mm_sub_epi16(q4, r0);
           const __m128i x2 = _mm_sub_epi16(q7, r1);
           const __m128i x3 = _mm_add_epi16(q7, r1);
           // Interleave to do the multiply by constants which gets us
           // into 32 bits.
           const __m128i t0 = _mm_unpacklo_epi16(x0, x3);
           const __m128i t1 = _mm_unpackhi_epi16(x0, x3);
           const __m128i t2 = _mm_unpacklo_epi16(x1, x2);
           const __m128i t3 = _mm_unpackhi_epi16(x1, x2);
@@ skipping 1266 matching lines @@
 #define FDCT32x32_HIGH_PRECISION 0
 #include "vp9/encoder/x86/vp9_dct32x32_avx2.c"
 #undef  FDCT32x32_2D_AVX2
 #undef  FDCT32x32_HIGH_PRECISION
 
 #define FDCT32x32_2D_AVX2 vp9_fdct32x32_avx2
 #define FDCT32x32_HIGH_PRECISION 1
 #include "vp9/encoder/x86/vp9_dct32x32_avx2.c" // NOLINT
 #undef  FDCT32x32_2D_AVX2
 #undef  FDCT32x32_HIGH_PRECISION