src/third_party/libvpx/source/libvpx/vp9/encoder/x86/vp9_dct_sse2.c

   1 /*
   2  *  Copyright (c) 2012 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include <emmintrin.h>  // SSE2
  12 #include "vp9/common/vp9_idct.h"  // for cospi constants
  13 #include "vpx_ports/mem.h"
  14
  15 void vp9_fdct4x4_sse2(const int16_t *input, int16_t *output, int stride) {
  16   // The 2D transform is done with two passes which are actually pretty
  17   // similar. In the first one, we transform the columns and transpose
  18   // the results. In the second one, we transform the rows. To achieve that,
  19   // as the first pass results are transposed, we tranpose the columns (that
  20   // is the transposed rows) and transpose the results (so that it goes back
  21   // in normal/row positions).
  22   int pass;
  23   // Constants
  24   //    When we use them, in one case, they are all the same. In all others
  25   //    it's a pair of them that we need to repeat four times. This is done
  26   //    by constructing the 32 bit constant corresponding to that pair.
  27   const __m128i k__cospi_p16_p16 = _mm_set1_epi16(cospi_16_64);
  28   const __m128i k__cospi_p16_m16 = pair_set_epi16(cospi_16_64, -cospi_16_64);
  29   const __m128i k__cospi_p24_p08 = pair_set_epi16(cospi_24_64, cospi_8_64);
  30   const __m128i k__cospi_m08_p24 = pair_set_epi16(-cospi_8_64, cospi_24_64);
  31   const __m128i k__DCT_CONST_ROUNDING = _mm_set1_epi32(DCT_CONST_ROUNDING);
  32   const __m128i k__nonzero_bias_a = _mm_setr_epi16(0, 1, 1, 1, 1, 1, 1, 1);
  33   const __m128i k__nonzero_bias_b = _mm_setr_epi16(1, 0, 0, 0, 0, 0, 0, 0);
  34   const __m128i kOne = _mm_set1_epi16(1);
  35   __m128i in0, in1, in2, in3;
  36   // Load inputs.
  37   {
  38     in0  = _mm_loadl_epi64((const __m128i *)(input +  0 * stride));
  39     in1  = _mm_loadl_epi64((const __m128i *)(input +  1 * stride));
  40     in2  = _mm_loadl_epi64((const __m128i *)(input +  2 * stride));
  41     in3  = _mm_loadl_epi64((const __m128i *)(input +  3 * stride));
  42     // x = x << 4
  43     in0 = _mm_slli_epi16(in0, 4);
  44     in1 = _mm_slli_epi16(in1, 4);
  45     in2 = _mm_slli_epi16(in2, 4);
  46     in3 = _mm_slli_epi16(in3, 4);
  47     // if (i == 0 && input[0]) input[0] += 1;
  48     {
  49       // The mask will only contain wether the first value is zero, all
  50       // other comparison will fail as something shifted by 4 (above << 4)
  51       // can never be equal to one. To increment in the non-zero case, we
  52       // add the mask and one for the first element:
  53       //   - if zero, mask = -1, v = v - 1 + 1 = v
  54       //   - if non-zero, mask = 0, v = v + 0 + 1 = v + 1
  55       __m128i mask = _mm_cmpeq_epi16(in0, k__nonzero_bias_a);
  56       in0 = _mm_add_epi16(in0, mask);
  57       in0 = _mm_add_epi16(in0, k__nonzero_bias_b);
  58     }
  59   }
  60   // Do the two transform/transpose passes
  61   for (pass = 0; pass < 2; ++pass) {
  62     // Transform 1/2: Add/substract
  63     const __m128i r0 = _mm_add_epi16(in0, in3);
  64     const __m128i r1 = _mm_add_epi16(in1, in2);
  65     const __m128i r2 = _mm_sub_epi16(in1, in2);
  66     const __m128i r3 = _mm_sub_epi16(in0, in3);
  67     // Transform 1/2: Interleave to do the multiply by constants which gets us
  68     //                into 32 bits.
  69     const __m128i t0 = _mm_unpacklo_epi16(r0, r1);
  70     const __m128i t2 = _mm_unpacklo_epi16(r2, r3);
  71     const __m128i u0 = _mm_madd_epi16(t0, k__cospi_p16_p16);
  72     const __m128i u2 = _mm_madd_epi16(t0, k__cospi_p16_m16);
  73     const __m128i u4 = _mm_madd_epi16(t2, k__cospi_p24_p08);
  74     const __m128i u6 = _mm_madd_epi16(t2, k__cospi_m08_p24);
  75     const __m128i v0 = _mm_add_epi32(u0, k__DCT_CONST_ROUNDING);
  76     const __m128i v2 = _mm_add_epi32(u2, k__DCT_CONST_ROUNDING);
  77     const __m128i v4 = _mm_add_epi32(u4, k__DCT_CONST_ROUNDING);
  78     const __m128i v6 = _mm_add_epi32(u6, k__DCT_CONST_ROUNDING);
  79     const __m128i w0 = _mm_srai_epi32(v0, DCT_CONST_BITS);
  80     const __m128i w2 = _mm_srai_epi32(v2, DCT_CONST_BITS);
  81     const __m128i w4 = _mm_srai_epi32(v4, DCT_CONST_BITS);
  82     const __m128i w6 = _mm_srai_epi32(v6, DCT_CONST_BITS);
  83     // Combine and transpose
  84     const __m128i res0 = _mm_packs_epi32(w0, w2);
  85     const __m128i res1 = _mm_packs_epi32(w4, w6);
  86     // 00 01 02 03 20 21 22 23
  87     // 10 11 12 13 30 31 32 33
  88     const __m128i tr0_0 = _mm_unpacklo_epi16(res0, res1);
  89     const __m128i tr0_1 = _mm_unpackhi_epi16(res0, res1);
  90     // 00 10 01 11 02 12 03 13
  91     // 20 30 21 31 22 32 23 33
  92     in0 = _mm_unpacklo_epi32(tr0_0, tr0_1);
  93     in2 = _mm_unpackhi_epi32(tr0_0, tr0_1);
  94     // 00 10 20 30 01 11 21 31      in0 contains 0 followed by 1
  95     // 02 12 22 32 03 13 23 33      in2 contains 2 followed by 3
  96     if (0 == pass) {
  97       // Extract values in the high part for second pass as transform code
  98       // only uses the first four values.
  99       in1 = _mm_unpackhi_epi64(in0, in0);
 100       in3 = _mm_unpackhi_epi64(in2, in2);
 101     } else {
 102       // Post-condition output and store it (v + 1) >> 2, taking advantage
 103       // of the fact 1/3 are stored just after 0/2.
 104       __m128i out01 = _mm_add_epi16(in0, kOne);
 105       __m128i out23 = _mm_add_epi16(in2, kOne);
 106       out01 = _mm_srai_epi16(out01, 2);
 107       out23 = _mm_srai_epi16(out23, 2);
 108       _mm_storeu_si128((__m128i *)(output + 0 * 4), out01);
 109       _mm_storeu_si128((__m128i *)(output + 2 * 4), out23);
 110     }
 111   }
 112 }
 113
 114 static INLINE void load_buffer_4x4(const int16_t *input, __m128i *in,
 115                                    int stride) {
 116   const __m128i k__nonzero_bias_a = _mm_setr_epi16(0, 1, 1, 1, 1, 1, 1, 1);
 117   const __m128i k__nonzero_bias_b = _mm_setr_epi16(1, 0, 0, 0, 0, 0, 0, 0);
 118   __m128i mask;
 119
 120   in[0] = _mm_loadl_epi64((const __m128i *)(input + 0 * stride));
 121   in[1] = _mm_loadl_epi64((const __m128i *)(input + 1 * stride));
 122   in[2] = _mm_loadl_epi64((const __m128i *)(input + 2 * stride));
 123   in[3] = _mm_loadl_epi64((const __m128i *)(input + 3 * stride));
 124
 125   in[0] = _mm_slli_epi16(in[0], 4);
 126   in[1] = _mm_slli_epi16(in[1], 4);
 127   in[2] = _mm_slli_epi16(in[2], 4);
 128   in[3] = _mm_slli_epi16(in[3], 4);
 129
 130   mask = _mm_cmpeq_epi16(in[0], k__nonzero_bias_a);
 131   in[0] = _mm_add_epi16(in[0], mask);
 132   in[0] = _mm_add_epi16(in[0], k__nonzero_bias_b);
 133 }
 134
 135 static INLINE void write_buffer_4x4(int16_t *output, __m128i *res) {
 136   const __m128i kOne = _mm_set1_epi16(1);
 137   __m128i in01 = _mm_unpacklo_epi64(res[0], res[1]);
 138   __m128i in23 = _mm_unpacklo_epi64(res[2], res[3]);
 139   __m128i out01 = _mm_add_epi16(in01, kOne);
 140   __m128i out23 = _mm_add_epi16(in23, kOne);
 141   out01 = _mm_srai_epi16(out01, 2);
 142   out23 = _mm_srai_epi16(out23, 2);
 143   _mm_store_si128((__m128i *)(output + 0 * 8), out01);
 144   _mm_store_si128((__m128i *)(output + 1 * 8), out23);
 145 }
 146
 147 static INLINE void transpose_4x4(__m128i *res) {
 148   // Combine and transpose
 149   // 00 01 02 03 20 21 22 23
 150   // 10 11 12 13 30 31 32 33
 151   const __m128i tr0_0 = _mm_unpacklo_epi16(res[0], res[1]);
 152   const __m128i tr0_1 = _mm_unpackhi_epi16(res[0], res[1]);
 153
 154   // 00 10 01 11 02 12 03 13
 155   // 20 30 21 31 22 32 23 33
 156   res[0] = _mm_unpacklo_epi32(tr0_0, tr0_1);
 157   res[2] = _mm_unpackhi_epi32(tr0_0, tr0_1);
 158
 159   // 00 10 20 30 01 11 21 31
 160   // 02 12 22 32 03 13 23 33
 161   // only use the first 4 16-bit integers
 162   res[1] = _mm_unpackhi_epi64(res[0], res[0]);
 163   res[3] = _mm_unpackhi_epi64(res[2], res[2]);
 164 }
 165
 166 void fdct4_1d_sse2(__m128i *in) {
 167   const __m128i k__cospi_p16_p16 = _mm_set1_epi16(cospi_16_64);
 168   const __m128i k__cospi_p16_m16 = pair_set_epi16(cospi_16_64, -cospi_16_64);
 169   const __m128i k__cospi_p08_p24 = pair_set_epi16(cospi_8_64, cospi_24_64);
 170   const __m128i k__cospi_p24_m08 = pair_set_epi16(cospi_24_64, -cospi_8_64);
 171   const __m128i k__DCT_CONST_ROUNDING = _mm_set1_epi32(DCT_CONST_ROUNDING);
 172
 173   __m128i u[4], v[4];
 174   u[0]=_mm_unpacklo_epi16(in[0], in[1]);
 175   u[1]=_mm_unpacklo_epi16(in[3], in[2]);
 176
 177   v[0] = _mm_add_epi16(u[0], u[1]);
 178   v[1] = _mm_sub_epi16(u[0], u[1]);
 179
 180   u[0] = _mm_madd_epi16(v[0], k__cospi_p16_p16);  // 0
 181   u[1] = _mm_madd_epi16(v[0], k__cospi_p16_m16);  // 2
 182   u[2] = _mm_madd_epi16(v[1], k__cospi_p08_p24);  // 1
 183   u[3] = _mm_madd_epi16(v[1], k__cospi_p24_m08);  // 3
 184
 185   v[0] = _mm_add_epi32(u[0], k__DCT_CONST_ROUNDING);
 186   v[1] = _mm_add_epi32(u[1], k__DCT_CONST_ROUNDING);
 187   v[2] = _mm_add_epi32(u[2], k__DCT_CONST_ROUNDING);
 188   v[3] = _mm_add_epi32(u[3], k__DCT_CONST_ROUNDING);
 189   u[0] = _mm_srai_epi32(v[0], DCT_CONST_BITS);
 190   u[1] = _mm_srai_epi32(v[1], DCT_CONST_BITS);
 191   u[2] = _mm_srai_epi32(v[2], DCT_CONST_BITS);
 192   u[3] = _mm_srai_epi32(v[3], DCT_CONST_BITS);
 193
 194   in[0] = _mm_packs_epi32(u[0], u[1]);
 195   in[1] = _mm_packs_epi32(u[2], u[3]);
 196   transpose_4x4(in);
 197 }
 198
 199 void fadst4_1d_sse2(__m128i *in) {
 200   const __m128i k__sinpi_p01_p02 = pair_set_epi16(sinpi_1_9, sinpi_2_9);
 201   const __m128i k__sinpi_p04_m01 = pair_set_epi16(sinpi_4_9, -sinpi_1_9);
 202   const __m128i k__sinpi_p03_p04 = pair_set_epi16(sinpi_3_9, sinpi_4_9);
 203   const __m128i k__sinpi_m03_p02 = pair_set_epi16(-sinpi_3_9, sinpi_2_9);
 204   const __m128i k__sinpi_p03_p03 = _mm_set1_epi16(sinpi_3_9);
 205   const __m128i kZero = _mm_set1_epi16(0);
 206   const __m128i k__DCT_CONST_ROUNDING = _mm_set1_epi32(DCT_CONST_ROUNDING);
 207   __m128i u[8], v[8];
 208   __m128i in7 = _mm_add_epi16(in[0], in[1]);
 209   in7 = _mm_sub_epi16(in7, in[3]);
 210
 211   u[0] = _mm_unpacklo_epi16(in[0], in[1]);
 212   u[1] = _mm_unpacklo_epi16(in[2], in[3]);
 213   u[2] = _mm_unpacklo_epi16(in7, kZero);
 214   u[3] = _mm_unpacklo_epi16(in[2], kZero);
 215
 216   v[0] = _mm_madd_epi16(u[0], k__sinpi_p01_p02);  // s0 + s2
 217   v[1] = _mm_madd_epi16(u[1], k__sinpi_p03_p04);  // s4 + s5
 218   v[2] = _mm_madd_epi16(u[2], k__sinpi_p03_p03);  // x1
 219   v[3] = _mm_madd_epi16(u[0], k__sinpi_p04_m01);  // s1 - s3
 220   v[4] = _mm_madd_epi16(u[1], k__sinpi_m03_p02);  // -s4 + s6
 221   v[5] = _mm_madd_epi16(u[3], k__sinpi_p03_p03);  // s4
 222
 223   u[0] = _mm_add_epi32(v[0], v[1]);
 224   u[1] = v[2];
 225   u[2] = _mm_add_epi32(v[3], v[4]);
 226   u[3] = _mm_sub_epi32(u[2], u[0]);
 227   u[4] = _mm_slli_epi32(v[5], 2);
 228   u[5] = _mm_sub_epi32(u[4], v[5]);
 229   u[6] = _mm_add_epi32(u[3], u[5]);
 230
 231   v[0] = _mm_add_epi32(u[0], k__DCT_CONST_ROUNDING);
 232   v[1] = _mm_add_epi32(u[1], k__DCT_CONST_ROUNDING);
 233   v[2] = _mm_add_epi32(u[2], k__DCT_CONST_ROUNDING);
 234   v[3] = _mm_add_epi32(u[6], k__DCT_CONST_ROUNDING);
 235
 236   u[0] = _mm_srai_epi32(v[0], DCT_CONST_BITS);
 237   u[1] = _mm_srai_epi32(v[1], DCT_CONST_BITS);
 238   u[2] = _mm_srai_epi32(v[2], DCT_CONST_BITS);
 239   u[3] = _mm_srai_epi32(v[3], DCT_CONST_BITS);
 240
 241   in[0] = _mm_packs_epi32(u[0], u[2]);
 242   in[1] = _mm_packs_epi32(u[1], u[3]);
 243   transpose_4x4(in);
 244 }
 245
 246 void vp9_short_fht4x4_sse2(const int16_t *input, int16_t *output,
 247                            int stride, int tx_type) {
 248   __m128i in[4];
 249   load_buffer_4x4(input, in, stride);
 250   switch (tx_type) {
 251     case 0:  // DCT_DCT
 252       fdct4_1d_sse2(in);
 253       fdct4_1d_sse2(in);
 254       break;
 255     case 1:  // ADST_DCT
 256       fadst4_1d_sse2(in);
 257       fdct4_1d_sse2(in);
 258       break;
 259     case 2:  // DCT_ADST
 260       fdct4_1d_sse2(in);
 261       fadst4_1d_sse2(in);
 262       break;
 263     case 3:  // ADST_ADST
 264       fadst4_1d_sse2(in);
 265       fadst4_1d_sse2(in);
 266       break;
 267     default:
 268       assert(0);
 269       break;
 270   }
 271   write_buffer_4x4(output, in);
 272 }
 273
 274 void vp9_fdct8x8_sse2(const int16_t *input, int16_t *output, int stride) {
 275   int pass;
 276   // Constants
 277   //    When we use them, in one case, they are all the same. In all others
 278   //    it's a pair of them that we need to repeat four times. This is done
 279   //    by constructing the 32 bit constant corresponding to that pair.
 280   const __m128i k__cospi_p16_p16 = _mm_set1_epi16(cospi_16_64);
 281   const __m128i k__cospi_p16_m16 = pair_set_epi16(cospi_16_64, -cospi_16_64);
 282   const __m128i k__cospi_p24_p08 = pair_set_epi16(cospi_24_64, cospi_8_64);
 283   const __m128i k__cospi_m08_p24 = pair_set_epi16(-cospi_8_64, cospi_24_64);
 284   const __m128i k__cospi_p28_p04 = pair_set_epi16(cospi_28_64, cospi_4_64);
 285   const __m128i k__cospi_m04_p28 = pair_set_epi16(-cospi_4_64, cospi_28_64);
 286   const __m128i k__cospi_p12_p20 = pair_set_epi16(cospi_12_64, cospi_20_64);
 287   const __m128i k__cospi_m20_p12 = pair_set_epi16(-cospi_20_64, cospi_12_64);
 288   const __m128i k__DCT_CONST_ROUNDING = _mm_set1_epi32(DCT_CONST_ROUNDING);
 289   // Load input
 290   __m128i in0  = _mm_load_si128((const __m128i *)(input + 0 * stride));
 291   __m128i in1  = _mm_load_si128((const __m128i *)(input + 1 * stride));
 292   __m128i in2  = _mm_load_si128((const __m128i *)(input + 2 * stride));
 293   __m128i in3  = _mm_load_si128((const __m128i *)(input + 3 * stride));
 294   __m128i in4  = _mm_load_si128((const __m128i *)(input + 4 * stride));
 295   __m128i in5  = _mm_load_si128((const __m128i *)(input + 5 * stride));
 296   __m128i in6  = _mm_load_si128((const __m128i *)(input + 6 * stride));
 297   __m128i in7  = _mm_load_si128((const __m128i *)(input + 7 * stride));
 298   // Pre-condition input (shift by two)
 299   in0 = _mm_slli_epi16(in0, 2);
 300   in1 = _mm_slli_epi16(in1, 2);
 301   in2 = _mm_slli_epi16(in2, 2);
 302   in3 = _mm_slli_epi16(in3, 2);
 303   in4 = _mm_slli_epi16(in4, 2);
 304   in5 = _mm_slli_epi16(in5, 2);
 305   in6 = _mm_slli_epi16(in6, 2);
 306   in7 = _mm_slli_epi16(in7, 2);
 307
 308   // We do two passes, first the columns, then the rows. The results of the
 309   // first pass are transposed so that the same column code can be reused. The
 310   // results of the second pass are also transposed so that the rows (processed
 311   // as columns) are put back in row positions.
 312   for (pass = 0; pass < 2; pass++) {
 313     // To store results of each pass before the transpose.
 314     __m128i res0, res1, res2, res3, res4, res5, res6, res7;
 315     // Add/substract
 316     const __m128i q0 = _mm_add_epi16(in0, in7);
 317     const __m128i q1 = _mm_add_epi16(in1, in6);
 318     const __m128i q2 = _mm_add_epi16(in2, in5);
 319     const __m128i q3 = _mm_add_epi16(in3, in4);
 320     const __m128i q4 = _mm_sub_epi16(in3, in4);
 321     const __m128i q5 = _mm_sub_epi16(in2, in5);
 322     const __m128i q6 = _mm_sub_epi16(in1, in6);
 323     const __m128i q7 = _mm_sub_epi16(in0, in7);
 324     // Work on first four results
 325     {
 326       // Add/substract
 327       const __m128i r0 = _mm_add_epi16(q0, q3);
 328       const __m128i r1 = _mm_add_epi16(q1, q2);
 329       const __m128i r2 = _mm_sub_epi16(q1, q2);
 330       const __m128i r3 = _mm_sub_epi16(q0, q3);
 331       // Interleave to do the multiply by constants which gets us into 32bits
 332       const __m128i t0 = _mm_unpacklo_epi16(r0, r1);
 333       const __m128i t1 = _mm_unpackhi_epi16(r0, r1);
 334       const __m128i t2 = _mm_unpacklo_epi16(r2, r3);
 335       const __m128i t3 = _mm_unpackhi_epi16(r2, r3);
 336       const __m128i u0 = _mm_madd_epi16(t0, k__cospi_p16_p16);
 337       const __m128i u1 = _mm_madd_epi16(t1, k__cospi_p16_p16);
 338       const __m128i u2 = _mm_madd_epi16(t0, k__cospi_p16_m16);
 339       const __m128i u3 = _mm_madd_epi16(t1, k__cospi_p16_m16);
 340       const __m128i u4 = _mm_madd_epi16(t2, k__cospi_p24_p08);
 341       const __m128i u5 = _mm_madd_epi16(t3, k__cospi_p24_p08);
 342       const __m128i u6 = _mm_madd_epi16(t2, k__cospi_m08_p24);
 343       const __m128i u7 = _mm_madd_epi16(t3, k__cospi_m08_p24);
 344       // dct_const_round_shift
 345       const __m128i v0 = _mm_add_epi32(u0, k__DCT_CONST_ROUNDING);
 346       const __m128i v1 = _mm_add_epi32(u1, k__DCT_CONST_ROUNDING);
 347       const __m128i v2 = _mm_add_epi32(u2, k__DCT_CONST_ROUNDING);
 348       const __m128i v3 = _mm_add_epi32(u3, k__DCT_CONST_ROUNDING);
 349       const __m128i v4 = _mm_add_epi32(u4, k__DCT_CONST_ROUNDING);
 350       const __m128i v5 = _mm_add_epi32(u5, k__DCT_CONST_ROUNDING);
 351       const __m128i v6 = _mm_add_epi32(u6, k__DCT_CONST_ROUNDING);
 352       const __m128i v7 = _mm_add_epi32(u7, k__DCT_CONST_ROUNDING);
 353       const __m128i w0 = _mm_srai_epi32(v0, DCT_CONST_BITS);
 354       const __m128i w1 = _mm_srai_epi32(v1, DCT_CONST_BITS);
 355       const __m128i w2 = _mm_srai_epi32(v2, DCT_CONST_BITS);
 356       const __m128i w3 = _mm_srai_epi32(v3, DCT_CONST_BITS);
 357       const __m128i w4 = _mm_srai_epi32(v4, DCT_CONST_BITS);
 358       const __m128i w5 = _mm_srai_epi32(v5, DCT_CONST_BITS);
 359       const __m128i w6 = _mm_srai_epi32(v6, DCT_CONST_BITS);
 360       const __m128i w7 = _mm_srai_epi32(v7, DCT_CONST_BITS);
 361       // Combine
 362       res0 = _mm_packs_epi32(w0, w1);
 363       res4 = _mm_packs_epi32(w2, w3);
 364       res2 = _mm_packs_epi32(w4, w5);
 365       res6 = _mm_packs_epi32(w6, w7);
 366     }
 367     // Work on next four results
 368     {
 369       // Interleave to do the multiply by constants which gets us into 32bits
 370       const __m128i d0 = _mm_unpacklo_epi16(q6, q5);
 371       const __m128i d1 = _mm_unpackhi_epi16(q6, q5);
 372       const __m128i e0 = _mm_madd_epi16(d0, k__cospi_p16_m16);
 373       const __m128i e1 = _mm_madd_epi16(d1, k__cospi_p16_m16);
 374       const __m128i e2 = _mm_madd_epi16(d0, k__cospi_p16_p16);
 375       const __m128i e3 = _mm_madd_epi16(d1, k__cospi_p16_p16);
 376       // dct_const_round_shift
 377       const __m128i f0 = _mm_add_epi32(e0, k__DCT_CONST_ROUNDING);
 378       const __m128i f1 = _mm_add_epi32(e1, k__DCT_CONST_ROUNDING);
 379       const __m128i f2 = _mm_add_epi32(e2, k__DCT_CONST_ROUNDING);
 380       const __m128i f3 = _mm_add_epi32(e3, k__DCT_CONST_ROUNDING);
 381       const __m128i s0 = _mm_srai_epi32(f0, DCT_CONST_BITS);
 382       const __m128i s1 = _mm_srai_epi32(f1, DCT_CONST_BITS);
 383       const __m128i s2 = _mm_srai_epi32(f2, DCT_CONST_BITS);
 384       const __m128i s3 = _mm_srai_epi32(f3, DCT_CONST_BITS);
 385       // Combine
 386       const __m128i r0 = _mm_packs_epi32(s0, s1);
 387       const __m128i r1 = _mm_packs_epi32(s2, s3);
 388       // Add/substract
 389       const __m128i x0 = _mm_add_epi16(q4, r0);
 390       const __m128i x1 = _mm_sub_epi16(q4, r0);
 391       const __m128i x2 = _mm_sub_epi16(q7, r1);
 392       const __m128i x3 = _mm_add_epi16(q7, r1);
 393       // Interleave to do the multiply by constants which gets us into 32bits
 394       const __m128i t0 = _mm_unpacklo_epi16(x0, x3);
 395       const __m128i t1 = _mm_unpackhi_epi16(x0, x3);
 396       const __m128i t2 = _mm_unpacklo_epi16(x1, x2);
 397       const __m128i t3 = _mm_unpackhi_epi16(x1, x2);
 398       const __m128i u0 = _mm_madd_epi16(t0, k__cospi_p28_p04);
 399       const __m128i u1 = _mm_madd_epi16(t1, k__cospi_p28_p04);
 400       const __m128i u2 = _mm_madd_epi16(t0, k__cospi_m04_p28);
 401       const __m128i u3 = _mm_madd_epi16(t1, k__cospi_m04_p28);
 402       const __m128i u4 = _mm_madd_epi16(t2, k__cospi_p12_p20);
 403       const __m128i u5 = _mm_madd_epi16(t3, k__cospi_p12_p20);
 404       const __m128i u6 = _mm_madd_epi16(t2, k__cospi_m20_p12);
 405       const __m128i u7 = _mm_madd_epi16(t3, k__cospi_m20_p12);
 406       // dct_const_round_shift
 407       const __m128i v0 = _mm_add_epi32(u0, k__DCT_CONST_ROUNDING);
 408       const __m128i v1 = _mm_add_epi32(u1, k__DCT_CONST_ROUNDING);
 409       const __m128i v2 = _mm_add_epi32(u2, k__DCT_CONST_ROUNDING);
 410       const __m128i v3 = _mm_add_epi32(u3, k__DCT_CONST_ROUNDING);
 411       const __m128i v4 = _mm_add_epi32(u4, k__DCT_CONST_ROUNDING);
 412       const __m128i v5 = _mm_add_epi32(u5, k__DCT_CONST_ROUNDING);
 413       const __m128i v6 = _mm_add_epi32(u6, k__DCT_CONST_ROUNDING);
 414       const __m128i v7 = _mm_add_epi32(u7, k__DCT_CONST_ROUNDING);
 415       const __m128i w0 = _mm_srai_epi32(v0, DCT_CONST_BITS);
 416       const __m128i w1 = _mm_srai_epi32(v1, DCT_CONST_BITS);
 417       const __m128i w2 = _mm_srai_epi32(v2, DCT_CONST_BITS);
 418       const __m128i w3 = _mm_srai_epi32(v3, DCT_CONST_BITS);
 419       const __m128i w4 = _mm_srai_epi32(v4, DCT_CONST_BITS);
 420       const __m128i w5 = _mm_srai_epi32(v5, DCT_CONST_BITS);
 421       const __m128i w6 = _mm_srai_epi32(v6, DCT_CONST_BITS);
 422       const __m128i w7 = _mm_srai_epi32(v7, DCT_CONST_BITS);
 423       // Combine
 424       res1 = _mm_packs_epi32(w0, w1);
 425       res7 = _mm_packs_epi32(w2, w3);
 426       res5 = _mm_packs_epi32(w4, w5);
 427       res3 = _mm_packs_epi32(w6, w7);
 428     }
 429     // Transpose the 8x8.
 430     {
 431       // 00 01 02 03 04 05 06 07
 432       // 10 11 12 13 14 15 16 17
 433       // 20 21 22 23 24 25 26 27
 434       // 30 31 32 33 34 35 36 37
 435       // 40 41 42 43 44 45 46 47
 436       // 50 51 52 53 54 55 56 57
 437       // 60 61 62 63 64 65 66 67
 438       // 70 71 72 73 74 75 76 77
 439       const __m128i tr0_0 = _mm_unpacklo_epi16(res0, res1);
 440       const __m128i tr0_1 = _mm_unpacklo_epi16(res2, res3);
 441       const __m128i tr0_2 = _mm_unpackhi_epi16(res0, res1);
 442       const __m128i tr0_3 = _mm_unpackhi_epi16(res2, res3);
 443       const __m128i tr0_4 = _mm_unpacklo_epi16(res4, res5);
 444       const __m128i tr0_5 = _mm_unpacklo_epi16(res6, res7);
 445       const __m128i tr0_6 = _mm_unpackhi_epi16(res4, res5);
 446       const __m128i tr0_7 = _mm_unpackhi_epi16(res6, res7);
 447       // 00 10 01 11 02 12 03 13
 448       // 20 30 21 31 22 32 23 33
 449       // 04 14 05 15 06 16 07 17
 450       // 24 34 25 35 26 36 27 37
 451       // 40 50 41 51 42 52 43 53
 452       // 60 70 61 71 62 72 63 73
 453       // 54 54 55 55 56 56 57 57
 454       // 64 74 65 75 66 76 67 77
 455       const __m128i tr1_0 = _mm_unpacklo_epi32(tr0_0, tr0_1);
 456       const __m128i tr1_1 = _mm_unpacklo_epi32(tr0_2, tr0_3);
 457       const __m128i tr1_2 = _mm_unpackhi_epi32(tr0_0, tr0_1);
 458       const __m128i tr1_3 = _mm_unpackhi_epi32(tr0_2, tr0_3);
 459       const __m128i tr1_4 = _mm_unpacklo_epi32(tr0_4, tr0_5);
 460       const __m128i tr1_5 = _mm_unpacklo_epi32(tr0_6, tr0_7);
 461       const __m128i tr1_6 = _mm_unpackhi_epi32(tr0_4, tr0_5);
 462       const __m128i tr1_7 = _mm_unpackhi_epi32(tr0_6, tr0_7);
 463       // 00 10 20 30 01 11 21 31
 464       // 40 50 60 70 41 51 61 71
 465       // 02 12 22 32 03 13 23 33
 466       // 42 52 62 72 43 53 63 73
 467       // 04 14 24 34 05 15 21 36
 468       // 44 54 64 74 45 55 61 76
 469       // 06 16 26 36 07 17 27 37
 470       // 46 56 66 76 47 57 67 77
 471       in0 = _mm_unpacklo_epi64(tr1_0, tr1_4);
 472       in1 = _mm_unpackhi_epi64(tr1_0, tr1_4);
 473       in2 = _mm_unpacklo_epi64(tr1_2, tr1_6);
 474       in3 = _mm_unpackhi_epi64(tr1_2, tr1_6);
 475       in4 = _mm_unpacklo_epi64(tr1_1, tr1_5);
 476       in5 = _mm_unpackhi_epi64(tr1_1, tr1_5);
 477       in6 = _mm_unpacklo_epi64(tr1_3, tr1_7);
 478       in7 = _mm_unpackhi_epi64(tr1_3, tr1_7);
 479       // 00 10 20 30 40 50 60 70
 480       // 01 11 21 31 41 51 61 71
 481       // 02 12 22 32 42 52 62 72
 482       // 03 13 23 33 43 53 63 73
 483       // 04 14 24 34 44 54 64 74
 484       // 05 15 25 35 45 55 65 75
 485       // 06 16 26 36 46 56 66 76
 486       // 07 17 27 37 47 57 67 77
 487     }
 488   }
 489   // Post-condition output and store it
 490   {
 491     // Post-condition (division by two)
 492     //    division of two 16 bits signed numbers using shifts
 493     //    n / 2 = (n - (n >> 15)) >> 1
 494     const __m128i sign_in0 = _mm_srai_epi16(in0, 15);
 495     const __m128i sign_in1 = _mm_srai_epi16(in1, 15);
 496     const __m128i sign_in2 = _mm_srai_epi16(in2, 15);
 497     const __m128i sign_in3 = _mm_srai_epi16(in3, 15);
 498     const __m128i sign_in4 = _mm_srai_epi16(in4, 15);
 499     const __m128i sign_in5 = _mm_srai_epi16(in5, 15);
 500     const __m128i sign_in6 = _mm_srai_epi16(in6, 15);
 501     const __m128i sign_in7 = _mm_srai_epi16(in7, 15);
 502     in0 = _mm_sub_epi16(in0, sign_in0);
 503     in1 = _mm_sub_epi16(in1, sign_in1);
 504     in2 = _mm_sub_epi16(in2, sign_in2);
 505     in3 = _mm_sub_epi16(in3, sign_in3);
 506     in4 = _mm_sub_epi16(in4, sign_in4);
 507     in5 = _mm_sub_epi16(in5, sign_in5);
 508     in6 = _mm_sub_epi16(in6, sign_in6);
 509     in7 = _mm_sub_epi16(in7, sign_in7);
 510     in0 = _mm_srai_epi16(in0, 1);
 511     in1 = _mm_srai_epi16(in1, 1);
 512     in2 = _mm_srai_epi16(in2, 1);
 513     in3 = _mm_srai_epi16(in3, 1);
 514     in4 = _mm_srai_epi16(in4, 1);
 515     in5 = _mm_srai_epi16(in5, 1);
 516     in6 = _mm_srai_epi16(in6, 1);
 517     in7 = _mm_srai_epi16(in7, 1);
 518     // store results
 519     _mm_store_si128((__m128i *)(output + 0 * 8), in0);
 520     _mm_store_si128((__m128i *)(output + 1 * 8), in1);
 521     _mm_store_si128((__m128i *)(output + 2 * 8), in2);
 522     _mm_store_si128((__m128i *)(output + 3 * 8), in3);
 523     _mm_store_si128((__m128i *)(output + 4 * 8), in4);
 524     _mm_store_si128((__m128i *)(output + 5 * 8), in5);
 525     _mm_store_si128((__m128i *)(output + 6 * 8), in6);
 526     _mm_store_si128((__m128i *)(output + 7 * 8), in7);
 527   }
 528 }
 529
 530 // load 8x8 array
 531 static INLINE void load_buffer_8x8(const int16_t *input, __m128i *in,
 532                                    int stride) {
 533   in[0]  = _mm_load_si128((const __m128i *)(input + 0 * stride));
 534   in[1]  = _mm_load_si128((const __m128i *)(input + 1 * stride));
 535   in[2]  = _mm_load_si128((const __m128i *)(input + 2 * stride));
 536   in[3]  = _mm_load_si128((const __m128i *)(input + 3 * stride));
 537   in[4]  = _mm_load_si128((const __m128i *)(input + 4 * stride));
 538   in[5]  = _mm_load_si128((const __m128i *)(input + 5 * stride));
 539   in[6]  = _mm_load_si128((const __m128i *)(input + 6 * stride));
 540   in[7]  = _mm_load_si128((const __m128i *)(input + 7 * stride));
 541
 542   in[0] = _mm_slli_epi16(in[0], 2);
 543   in[1] = _mm_slli_epi16(in[1], 2);
 544   in[2] = _mm_slli_epi16(in[2], 2);
 545   in[3] = _mm_slli_epi16(in[3], 2);
 546   in[4] = _mm_slli_epi16(in[4], 2);
 547   in[5] = _mm_slli_epi16(in[5], 2);
 548   in[6] = _mm_slli_epi16(in[6], 2);
 549   in[7] = _mm_slli_epi16(in[7], 2);
 550 }
 551
 552 // right shift and rounding
 553 static INLINE void right_shift_8x8(__m128i *res, int const bit) {
 554   const __m128i kOne = _mm_set1_epi16(1);
 555   const int bit_m02 = bit - 2;
 556   __m128i sign0 = _mm_srai_epi16(res[0], 15);
 557   __m128i sign1 = _mm_srai_epi16(res[1], 15);
 558   __m128i sign2 = _mm_srai_epi16(res[2], 15);
 559   __m128i sign3 = _mm_srai_epi16(res[3], 15);
 560   __m128i sign4 = _mm_srai_epi16(res[4], 15);
 561   __m128i sign5 = _mm_srai_epi16(res[5], 15);
 562   __m128i sign6 = _mm_srai_epi16(res[6], 15);
 563   __m128i sign7 = _mm_srai_epi16(res[7], 15);
 564
 565   if (bit_m02 >= 0) {
 566     __m128i k_const_rounding = _mm_slli_epi16(kOne, bit_m02);
 567     res[0] = _mm_add_epi16(res[0], k_const_rounding);
 568     res[1] = _mm_add_epi16(res[1], k_const_rounding);
 569     res[2] = _mm_add_epi16(res[2], k_const_rounding);
 570     res[3] = _mm_add_epi16(res[3], k_const_rounding);
 571     res[4] = _mm_add_epi16(res[4], k_const_rounding);
 572     res[5] = _mm_add_epi16(res[5], k_const_rounding);
 573     res[6] = _mm_add_epi16(res[6], k_const_rounding);
 574     res[7] = _mm_add_epi16(res[7], k_const_rounding);
 575   }
 576
 577   res[0] = _mm_sub_epi16(res[0], sign0);
 578   res[1] = _mm_sub_epi16(res[1], sign1);
 579   res[2] = _mm_sub_epi16(res[2], sign2);
 580   res[3] = _mm_sub_epi16(res[3], sign3);
 581   res[4] = _mm_sub_epi16(res[4], sign4);
 582   res[5] = _mm_sub_epi16(res[5], sign5);
 583   res[6] = _mm_sub_epi16(res[6], sign6);
 584   res[7] = _mm_sub_epi16(res[7], sign7);
 585
 586   res[0] = _mm_srai_epi16(res[0], bit);
 587   res[1] = _mm_srai_epi16(res[1], bit);
 588   res[2] = _mm_srai_epi16(res[2], bit);
 589   res[3] = _mm_srai_epi16(res[3], bit);
 590   res[4] = _mm_srai_epi16(res[4], bit);
 591   res[5] = _mm_srai_epi16(res[5], bit);
 592   res[6] = _mm_srai_epi16(res[6], bit);
 593   res[7] = _mm_srai_epi16(res[7], bit);
 594 }
 595
 596 // write 8x8 array
 597 static INLINE void write_buffer_8x8(int16_t *output, __m128i *res, int stride) {
 598   _mm_store_si128((__m128i *)(output + 0 * stride), res[0]);
 599   _mm_store_si128((__m128i *)(output + 1 * stride), res[1]);
 600   _mm_store_si128((__m128i *)(output + 2 * stride), res[2]);
 601   _mm_store_si128((__m128i *)(output + 3 * stride), res[3]);
 602   _mm_store_si128((__m128i *)(output + 4 * stride), res[4]);
 603   _mm_store_si128((__m128i *)(output + 5 * stride), res[5]);
 604   _mm_store_si128((__m128i *)(output + 6 * stride), res[6]);
 605   _mm_store_si128((__m128i *)(output + 7 * stride), res[7]);
 606 }
 607
 608 // perform in-place transpose
 609 static INLINE void array_transpose_8x8(__m128i *in, __m128i *res) {
 610   const __m128i tr0_0 = _mm_unpacklo_epi16(in[0], in[1]);
 611   const __m128i tr0_1 = _mm_unpacklo_epi16(in[2], in[3]);
 612   const __m128i tr0_2 = _mm_unpackhi_epi16(in[0], in[1]);
 613   const __m128i tr0_3 = _mm_unpackhi_epi16(in[2], in[3]);
 614   const __m128i tr0_4 = _mm_unpacklo_epi16(in[4], in[5]);
 615   const __m128i tr0_5 = _mm_unpacklo_epi16(in[6], in[7]);
 616   const __m128i tr0_6 = _mm_unpackhi_epi16(in[4], in[5]);
 617   const __m128i tr0_7 = _mm_unpackhi_epi16(in[6], in[7]);
 618   // 00 10 01 11 02 12 03 13
 619   // 20 30 21 31 22 32 23 33
 620   // 04 14 05 15 06 16 07 17
 621   // 24 34 25 35 26 36 27 37
 622   // 40 50 41 51 42 52 43 53
 623   // 60 70 61 71 62 72 63 73
 624   // 44 54 45 55 46 56 47 57
 625   // 64 74 65 75 66 76 67 77
 626   const __m128i tr1_0 = _mm_unpacklo_epi32(tr0_0, tr0_1);
 627   const __m128i tr1_1 = _mm_unpacklo_epi32(tr0_4, tr0_5);
 628   const __m128i tr1_2 = _mm_unpackhi_epi32(tr0_0, tr0_1);
 629   const __m128i tr1_3 = _mm_unpackhi_epi32(tr0_4, tr0_5);
 630   const __m128i tr1_4 = _mm_unpacklo_epi32(tr0_2, tr0_3);
 631   const __m128i tr1_5 = _mm_unpacklo_epi32(tr0_6, tr0_7);
 632   const __m128i tr1_6 = _mm_unpackhi_epi32(tr0_2, tr0_3);
 633   const __m128i tr1_7 = _mm_unpackhi_epi32(tr0_6, tr0_7);
 634   // 00 10 20 30 01 11 21 31
 635   // 40 50 60 70 41 51 61 71
 636   // 02 12 22 32 03 13 23 33
 637   // 42 52 62 72 43 53 63 73
 638   // 04 14 24 34 05 15 25 35
 639   // 44 54 64 74 45 55 65 75
 640   // 06 16 26 36 07 17 27 37
 641   // 46 56 66 76 47 57 67 77
 642   res[0] = _mm_unpacklo_epi64(tr1_0, tr1_1);
 643   res[1] = _mm_unpackhi_epi64(tr1_0, tr1_1);
 644   res[2] = _mm_unpacklo_epi64(tr1_2, tr1_3);
 645   res[3] = _mm_unpackhi_epi64(tr1_2, tr1_3);
 646   res[4] = _mm_unpacklo_epi64(tr1_4, tr1_5);
 647   res[5] = _mm_unpackhi_epi64(tr1_4, tr1_5);
 648   res[6] = _mm_unpacklo_epi64(tr1_6, tr1_7);
 649   res[7] = _mm_unpackhi_epi64(tr1_6, tr1_7);
 650   // 00 10 20 30 40 50 60 70
 651   // 01 11 21 31 41 51 61 71
 652   // 02 12 22 32 42 52 62 72
 653   // 03 13 23 33 43 53 63 73
 654   // 04 14 24 34 44 54 64 74
 655   // 05 15 25 35 45 55 65 75
 656   // 06 16 26 36 46 56 66 76
 657   // 07 17 27 37 47 57 67 77
 658 }
 659
 660 void fdct8_1d_sse2(__m128i *in) {
 661   // constants
 662   const __m128i k__cospi_p16_p16 = _mm_set1_epi16(cospi_16_64);
 663   const __m128i k__cospi_p16_m16 = pair_set_epi16(cospi_16_64, -cospi_16_64);
 664   const __m128i k__cospi_p24_p08 = pair_set_epi16(cospi_24_64, cospi_8_64);
 665   const __m128i k__cospi_m08_p24 = pair_set_epi16(-cospi_8_64, cospi_24_64);
 666   const __m128i k__cospi_p28_p04 = pair_set_epi16(cospi_28_64, cospi_4_64);
 667   const __m128i k__cospi_m04_p28 = pair_set_epi16(-cospi_4_64, cospi_28_64);
 668   const __m128i k__cospi_p12_p20 = pair_set_epi16(cospi_12_64, cospi_20_64);
 669   const __m128i k__cospi_m20_p12 = pair_set_epi16(-cospi_20_64, cospi_12_64);
 670   const __m128i k__DCT_CONST_ROUNDING = _mm_set1_epi32(DCT_CONST_ROUNDING);
 671   __m128i u0, u1, u2, u3, u4, u5, u6, u7;
 672   __m128i v0, v1, v2, v3, v4, v5, v6, v7;
 673   __m128i s0, s1, s2, s3, s4, s5, s6, s7;
 674
 675   // stage 1
 676   s0 = _mm_add_epi16(in[0], in[7]);
 677   s1 = _mm_add_epi16(in[1], in[6]);
 678   s2 = _mm_add_epi16(in[2], in[5]);
 679   s3 = _mm_add_epi16(in[3], in[4]);
 680   s4 = _mm_sub_epi16(in[3], in[4]);
 681   s5 = _mm_sub_epi16(in[2], in[5]);
 682   s6 = _mm_sub_epi16(in[1], in[6]);
 683   s7 = _mm_sub_epi16(in[0], in[7]);
 684
 685   u0 = _mm_add_epi16(s0, s3);
 686   u1 = _mm_add_epi16(s1, s2);
 687   u2 = _mm_sub_epi16(s1, s2);
 688   u3 = _mm_sub_epi16(s0, s3);
 689   // interleave and perform butterfly multiplication/addition
 690   v0 = _mm_unpacklo_epi16(u0, u1);
 691   v1 = _mm_unpackhi_epi16(u0, u1);
 692   v2 = _mm_unpacklo_epi16(u2, u3);
 693   v3 = _mm_unpackhi_epi16(u2, u3);
 694
 695   u0 = _mm_madd_epi16(v0, k__cospi_p16_p16);
 696   u1 = _mm_madd_epi16(v1, k__cospi_p16_p16);
 697   u2 = _mm_madd_epi16(v0, k__cospi_p16_m16);
 698   u3 = _mm_madd_epi16(v1, k__cospi_p16_m16);
 699   u4 = _mm_madd_epi16(v2, k__cospi_p24_p08);
 700   u5 = _mm_madd_epi16(v3, k__cospi_p24_p08);
 701   u6 = _mm_madd_epi16(v2, k__cospi_m08_p24);
 702   u7 = _mm_madd_epi16(v3, k__cospi_m08_p24);
 703
 704   // shift and rounding
 705   v0 = _mm_add_epi32(u0, k__DCT_CONST_ROUNDING);
 706   v1 = _mm_add_epi32(u1, k__DCT_CONST_ROUNDING);
 707   v2 = _mm_add_epi32(u2, k__DCT_CONST_ROUNDING);
 708   v3 = _mm_add_epi32(u3, k__DCT_CONST_ROUNDING);
 709   v4 = _mm_add_epi32(u4, k__DCT_CONST_ROUNDING);
 710   v5 = _mm_add_epi32(u5, k__DCT_CONST_ROUNDING);
 711   v6 = _mm_add_epi32(u6, k__DCT_CONST_ROUNDING);
 712   v7 = _mm_add_epi32(u7, k__DCT_CONST_ROUNDING);
 713
 714   u0 = _mm_srai_epi32(v0, DCT_CONST_BITS);
 715   u1 = _mm_srai_epi32(v1, DCT_CONST_BITS);
 716   u2 = _mm_srai_epi32(v2, DCT_CONST_BITS);
 717   u3 = _mm_srai_epi32(v3, DCT_CONST_BITS);
 718   u4 = _mm_srai_epi32(v4, DCT_CONST_BITS);
 719   u5 = _mm_srai_epi32(v5, DCT_CONST_BITS);
 720   u6 = _mm_srai_epi32(v6, DCT_CONST_BITS);
 721   u7 = _mm_srai_epi32(v7, DCT_CONST_BITS);
 722
 723   in[0] = _mm_packs_epi32(u0, u1);
 724   in[2] = _mm_packs_epi32(u4, u5);
 725   in[4] = _mm_packs_epi32(u2, u3);
 726   in[6] = _mm_packs_epi32(u6, u7);
 727
 728   // stage 2
 729   // interleave and perform butterfly multiplication/addition
 730   u0 = _mm_unpacklo_epi16(s6, s5);
 731   u1 = _mm_unpackhi_epi16(s6, s5);
 732   v0 = _mm_madd_epi16(u0, k__cospi_p16_m16);
 733   v1 = _mm_madd_epi16(u1, k__cospi_p16_m16);
 734   v2 = _mm_madd_epi16(u0, k__cospi_p16_p16);
 735   v3 = _mm_madd_epi16(u1, k__cospi_p16_p16);
 736
 737   // shift and rounding
 738   u0 = _mm_add_epi32(v0, k__DCT_CONST_ROUNDING);
 739   u1 = _mm_add_epi32(v1, k__DCT_CONST_ROUNDING);
 740   u2 = _mm_add_epi32(v2, k__DCT_CONST_ROUNDING);
 741   u3 = _mm_add_epi32(v3, k__DCT_CONST_ROUNDING);
 742
 743   v0 = _mm_srai_epi32(u0, DCT_CONST_BITS);
 744   v1 = _mm_srai_epi32(u1, DCT_CONST_BITS);
 745   v2 = _mm_srai_epi32(u2, DCT_CONST_BITS);
 746   v3 = _mm_srai_epi32(u3, DCT_CONST_BITS);
 747
 748   u0 = _mm_packs_epi32(v0, v1);
 749   u1 = _mm_packs_epi32(v2, v3);
 750
 751   // stage 3
 752   s0 = _mm_add_epi16(s4, u0);
 753   s1 = _mm_sub_epi16(s4, u0);
 754   s2 = _mm_sub_epi16(s7, u1);
 755   s3 = _mm_add_epi16(s7, u1);
 756
 757   // stage 4
 758   u0 = _mm_unpacklo_epi16(s0, s3);
 759   u1 = _mm_unpackhi_epi16(s0, s3);
 760   u2 = _mm_unpacklo_epi16(s1, s2);
 761   u3 = _mm_unpackhi_epi16(s1, s2);
 762
 763   v0 = _mm_madd_epi16(u0, k__cospi_p28_p04);
 764   v1 = _mm_madd_epi16(u1, k__cospi_p28_p04);
 765   v2 = _mm_madd_epi16(u2, k__cospi_p12_p20);
 766   v3 = _mm_madd_epi16(u3, k__cospi_p12_p20);
 767   v4 = _mm_madd_epi16(u2, k__cospi_m20_p12);
 768   v5 = _mm_madd_epi16(u3, k__cospi_m20_p12);
 769   v6 = _mm_madd_epi16(u0, k__cospi_m04_p28);
 770   v7 = _mm_madd_epi16(u1, k__cospi_m04_p28);
 771
 772   // shift and rounding
 773   u0 = _mm_add_epi32(v0, k__DCT_CONST_ROUNDING);
 774   u1 = _mm_add_epi32(v1, k__DCT_CONST_ROUNDING);
 775   u2 = _mm_add_epi32(v2, k__DCT_CONST_ROUNDING);
 776   u3 = _mm_add_epi32(v3, k__DCT_CONST_ROUNDING);
 777   u4 = _mm_add_epi32(v4, k__DCT_CONST_ROUNDING);
 778   u5 = _mm_add_epi32(v5, k__DCT_CONST_ROUNDING);
 779   u6 = _mm_add_epi32(v6, k__DCT_CONST_ROUNDING);
 780   u7 = _mm_add_epi32(v7, k__DCT_CONST_ROUNDING);
 781
 782   v0 = _mm_srai_epi32(u0, DCT_CONST_BITS);
 783   v1 = _mm_srai_epi32(u1, DCT_CONST_BITS);
 784   v2 = _mm_srai_epi32(u2, DCT_CONST_BITS);
 785   v3 = _mm_srai_epi32(u3, DCT_CONST_BITS);
 786   v4 = _mm_srai_epi32(u4, DCT_CONST_BITS);
 787   v5 = _mm_srai_epi32(u5, DCT_CONST_BITS);
 788   v6 = _mm_srai_epi32(u6, DCT_CONST_BITS);
 789   v7 = _mm_srai_epi32(u7, DCT_CONST_BITS);
 790
 791   in[1] = _mm_packs_epi32(v0, v1);
 792   in[3] = _mm_packs_epi32(v4, v5);
 793   in[5] = _mm_packs_epi32(v2, v3);
 794   in[7] = _mm_packs_epi32(v6, v7);
 795
 796   // transpose
 797   array_transpose_8x8(in, in);
 798 }
 799
 800 void fadst8_1d_sse2(__m128i *in) {
 801   // Constants
 802   const __m128i k__cospi_p02_p30 = pair_set_epi16(cospi_2_64, cospi_30_64);
 803   const __m128i k__cospi_p30_m02 = pair_set_epi16(cospi_30_64, -cospi_2_64);
 804   const __m128i k__cospi_p10_p22 = pair_set_epi16(cospi_10_64, cospi_22_64);
 805   const __m128i k__cospi_p22_m10 = pair_set_epi16(cospi_22_64, -cospi_10_64);
 806   const __m128i k__cospi_p18_p14 = pair_set_epi16(cospi_18_64, cospi_14_64);
 807   const __m128i k__cospi_p14_m18 = pair_set_epi16(cospi_14_64, -cospi_18_64);
 808   const __m128i k__cospi_p26_p06 = pair_set_epi16(cospi_26_64, cospi_6_64);
 809   const __m128i k__cospi_p06_m26 = pair_set_epi16(cospi_6_64, -cospi_26_64);
 810   const __m128i k__cospi_p08_p24 = pair_set_epi16(cospi_8_64, cospi_24_64);
 811   const __m128i k__cospi_p24_m08 = pair_set_epi16(cospi_24_64, -cospi_8_64);
 812   const __m128i k__cospi_m24_p08 = pair_set_epi16(-cospi_24_64, cospi_8_64);
 813   const __m128i k__cospi_p16_m16 = pair_set_epi16(cospi_16_64, -cospi_16_64);
 814   const __m128i k__cospi_p16_p16 = _mm_set1_epi16(cospi_16_64);
 815   const __m128i k__const_0 = _mm_set1_epi16(0);
 816   const __m128i k__DCT_CONST_ROUNDING = _mm_set1_epi32(DCT_CONST_ROUNDING);
 817
 818   __m128i u0, u1, u2, u3, u4, u5, u6, u7, u8, u9, u10, u11, u12, u13, u14, u15;
 819   __m128i v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15;
 820   __m128i w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
 821   __m128i s0, s1, s2, s3, s4, s5, s6, s7;
 822   __m128i in0, in1, in2, in3, in4, in5, in6, in7;
 823
 824   // properly aligned for butterfly input
 825   in0  = in[7];
 826   in1  = in[0];
 827   in2  = in[5];
 828   in3  = in[2];
 829   in4  = in[3];
 830   in5  = in[4];
 831   in6  = in[1];
 832   in7  = in[6];
 833
 834   // column transformation
 835   // stage 1
 836   // interleave and multiply/add into 32-bit integer
 837   s0 = _mm_unpacklo_epi16(in0, in1);
 838   s1 = _mm_unpackhi_epi16(in0, in1);
 839   s2 = _mm_unpacklo_epi16(in2, in3);
 840   s3 = _mm_unpackhi_epi16(in2, in3);
 841   s4 = _mm_unpacklo_epi16(in4, in5);
 842   s5 = _mm_unpackhi_epi16(in4, in5);
 843   s6 = _mm_unpacklo_epi16(in6, in7);
 844   s7 = _mm_unpackhi_epi16(in6, in7);
 845
 846   u0 = _mm_madd_epi16(s0, k__cospi_p02_p30);
 847   u1 = _mm_madd_epi16(s1, k__cospi_p02_p30);
 848   u2 = _mm_madd_epi16(s0, k__cospi_p30_m02);
 849   u3 = _mm_madd_epi16(s1, k__cospi_p30_m02);
 850   u4 = _mm_madd_epi16(s2, k__cospi_p10_p22);
 851   u5 = _mm_madd_epi16(s3, k__cospi_p10_p22);
 852   u6 = _mm_madd_epi16(s2, k__cospi_p22_m10);
 853   u7 = _mm_madd_epi16(s3, k__cospi_p22_m10);
 854   u8 = _mm_madd_epi16(s4, k__cospi_p18_p14);
 855   u9 = _mm_madd_epi16(s5, k__cospi_p18_p14);
 856   u10 = _mm_madd_epi16(s4, k__cospi_p14_m18);
 857   u11 = _mm_madd_epi16(s5, k__cospi_p14_m18);
 858   u12 = _mm_madd_epi16(s6, k__cospi_p26_p06);
 859   u13 = _mm_madd_epi16(s7, k__cospi_p26_p06);
 860   u14 = _mm_madd_epi16(s6, k__cospi_p06_m26);
 861   u15 = _mm_madd_epi16(s7, k__cospi_p06_m26);
 862
 863   // addition
 864   w0 = _mm_add_epi32(u0, u8);
 865   w1 = _mm_add_epi32(u1, u9);
 866   w2 = _mm_add_epi32(u2, u10);
 867   w3 = _mm_add_epi32(u3, u11);
 868   w4 = _mm_add_epi32(u4, u12);
 869   w5 = _mm_add_epi32(u5, u13);
 870   w6 = _mm_add_epi32(u6, u14);
 871   w7 = _mm_add_epi32(u7, u15);
 872   w8 = _mm_sub_epi32(u0, u8);
 873   w9 = _mm_sub_epi32(u1, u9);
 874   w10 = _mm_sub_epi32(u2, u10);
 875   w11 = _mm_sub_epi32(u3, u11);
 876   w12 = _mm_sub_epi32(u4, u12);
 877   w13 = _mm_sub_epi32(u5, u13);
 878   w14 = _mm_sub_epi32(u6, u14);
 879   w15 = _mm_sub_epi32(u7, u15);
 880
 881   // shift and rounding
 882   v0 = _mm_add_epi32(w0, k__DCT_CONST_ROUNDING);
 883   v1 = _mm_add_epi32(w1, k__DCT_CONST_ROUNDING);
 884   v2 = _mm_add_epi32(w2, k__DCT_CONST_ROUNDING);
 885   v3 = _mm_add_epi32(w3, k__DCT_CONST_ROUNDING);
 886   v4 = _mm_add_epi32(w4, k__DCT_CONST_ROUNDING);
 887   v5 = _mm_add_epi32(w5, k__DCT_CONST_ROUNDING);
 888   v6 = _mm_add_epi32(w6, k__DCT_CONST_ROUNDING);
 889   v7 = _mm_add_epi32(w7, k__DCT_CONST_ROUNDING);
 890   v8 = _mm_add_epi32(w8, k__DCT_CONST_ROUNDING);
 891   v9 = _mm_add_epi32(w9, k__DCT_CONST_ROUNDING);
 892   v10 = _mm_add_epi32(w10, k__DCT_CONST_ROUNDING);
 893   v11 = _mm_add_epi32(w11, k__DCT_CONST_ROUNDING);
 894   v12 = _mm_add_epi32(w12, k__DCT_CONST_ROUNDING);
 895   v13 = _mm_add_epi32(w13, k__DCT_CONST_ROUNDING);
 896   v14 = _mm_add_epi32(w14, k__DCT_CONST_ROUNDING);
 897   v15 = _mm_add_epi32(w15, k__DCT_CONST_ROUNDING);
 898
 899   u0 = _mm_srai_epi32(v0, DCT_CONST_BITS);
 900   u1 = _mm_srai_epi32(v1, DCT_CONST_BITS);
 901   u2 = _mm_srai_epi32(v2, DCT_CONST_BITS);
 902   u3 = _mm_srai_epi32(v3, DCT_CONST_BITS);
 903   u4 = _mm_srai_epi32(v4, DCT_CONST_BITS);
 904   u5 = _mm_srai_epi32(v5, DCT_CONST_BITS);
 905   u6 = _mm_srai_epi32(v6, DCT_CONST_BITS);
 906   u7 = _mm_srai_epi32(v7, DCT_CONST_BITS);
 907   u8 = _mm_srai_epi32(v8, DCT_CONST_BITS);
 908   u9 = _mm_srai_epi32(v9, DCT_CONST_BITS);
 909   u10 = _mm_srai_epi32(v10, DCT_CONST_BITS);
 910   u11 = _mm_srai_epi32(v11, DCT_CONST_BITS);
 911   u12 = _mm_srai_epi32(v12, DCT_CONST_BITS);
 912   u13 = _mm_srai_epi32(v13, DCT_CONST_BITS);
 913   u14 = _mm_srai_epi32(v14, DCT_CONST_BITS);
 914   u15 = _mm_srai_epi32(v15, DCT_CONST_BITS);
 915
 916   // back to 16-bit and pack 8 integers into __m128i
 917   in[0] = _mm_packs_epi32(u0, u1);
 918   in[1] = _mm_packs_epi32(u2, u3);
 919   in[2] = _mm_packs_epi32(u4, u5);
 920   in[3] = _mm_packs_epi32(u6, u7);
 921   in[4] = _mm_packs_epi32(u8, u9);
 922   in[5] = _mm_packs_epi32(u10, u11);
 923   in[6] = _mm_packs_epi32(u12, u13);
 924   in[7] = _mm_packs_epi32(u14, u15);
 925
 926   // stage 2
 927   s0 = _mm_add_epi16(in[0], in[2]);
 928   s1 = _mm_add_epi16(in[1], in[3]);
 929   s2 = _mm_sub_epi16(in[0], in[2]);
 930   s3 = _mm_sub_epi16(in[1], in[3]);
 931   u0 = _mm_unpacklo_epi16(in[4], in[5]);
 932   u1 = _mm_unpackhi_epi16(in[4], in[5]);
 933   u2 = _mm_unpacklo_epi16(in[6], in[7]);
 934   u3 = _mm_unpackhi_epi16(in[6], in[7]);
 935
 936   v0 = _mm_madd_epi16(u0, k__cospi_p08_p24);
 937   v1 = _mm_madd_epi16(u1, k__cospi_p08_p24);
 938   v2 = _mm_madd_epi16(u0, k__cospi_p24_m08);
 939   v3 = _mm_madd_epi16(u1, k__cospi_p24_m08);
 940   v4 = _mm_madd_epi16(u2, k__cospi_m24_p08);
 941   v5 = _mm_madd_epi16(u3, k__cospi_m24_p08);
 942   v6 = _mm_madd_epi16(u2, k__cospi_p08_p24);
 943   v7 = _mm_madd_epi16(u3, k__cospi_p08_p24);
 944
 945   w0 = _mm_add_epi32(v0, v4);
 946   w1 = _mm_add_epi32(v1, v5);
 947   w2 = _mm_add_epi32(v2, v6);
 948   w3 = _mm_add_epi32(v3, v7);
 949   w4 = _mm_sub_epi32(v0, v4);
 950   w5 = _mm_sub_epi32(v1, v5);
 951   w6 = _mm_sub_epi32(v2, v6);
 952   w7 = _mm_sub_epi32(v3, v7);
 953
 954   v0 = _mm_add_epi32(w0, k__DCT_CONST_ROUNDING);
 955   v1 = _mm_add_epi32(w1, k__DCT_CONST_ROUNDING);
 956   v2 = _mm_add_epi32(w2, k__DCT_CONST_ROUNDING);
 957   v3 = _mm_add_epi32(w3, k__DCT_CONST_ROUNDING);
 958   v4 = _mm_add_epi32(w4, k__DCT_CONST_ROUNDING);
 959   v5 = _mm_add_epi32(w5, k__DCT_CONST_ROUNDING);
 960   v6 = _mm_add_epi32(w6, k__DCT_CONST_ROUNDING);
 961   v7 = _mm_add_epi32(w7, k__DCT_CONST_ROUNDING);
 962
 963   u0 = _mm_srai_epi32(v0, DCT_CONST_BITS);
 964   u1 = _mm_srai_epi32(v1, DCT_CONST_BITS);
 965   u2 = _mm_srai_epi32(v2, DCT_CONST_BITS);
 966   u3 = _mm_srai_epi32(v3, DCT_CONST_BITS);
 967   u4 = _mm_srai_epi32(v4, DCT_CONST_BITS);
 968   u5 = _mm_srai_epi32(v5, DCT_CONST_BITS);
 969   u6 = _mm_srai_epi32(v6, DCT_CONST_BITS);
 970   u7 = _mm_srai_epi32(v7, DCT_CONST_BITS);
 971
 972   // back to 16-bit intergers
 973   s4 = _mm_packs_epi32(u0, u1);
 974   s5 = _mm_packs_epi32(u2, u3);
 975   s6 = _mm_packs_epi32(u4, u5);
 976   s7 = _mm_packs_epi32(u6, u7);
 977
 978   // stage 3
 979   u0 = _mm_unpacklo_epi16(s2, s3);
 980   u1 = _mm_unpackhi_epi16(s2, s3);
 981   u2 = _mm_unpacklo_epi16(s6, s7);
 982   u3 = _mm_unpackhi_epi16(s6, s7);
 983
 984   v0 = _mm_madd_epi16(u0, k__cospi_p16_p16);
 985   v1 = _mm_madd_epi16(u1, k__cospi_p16_p16);
 986   v2 = _mm_madd_epi16(u0, k__cospi_p16_m16);
 987   v3 = _mm_madd_epi16(u1, k__cospi_p16_m16);
 988   v4 = _mm_madd_epi16(u2, k__cospi_p16_p16);
 989   v5 = _mm_madd_epi16(u3, k__cospi_p16_p16);
 990   v6 = _mm_madd_epi16(u2, k__cospi_p16_m16);
 991   v7 = _mm_madd_epi16(u3, k__cospi_p16_m16);
 992
 993   u0 = _mm_add_epi32(v0, k__DCT_CONST_ROUNDING);
 994   u1 = _mm_add_epi32(v1, k__DCT_CONST_ROUNDING);
 995   u2 = _mm_add_epi32(v2, k__DCT_CONST_ROUNDING);
 996   u3 = _mm_add_epi32(v3, k__DCT_CONST_ROUNDING);
 997   u4 = _mm_add_epi32(v4, k__DCT_CONST_ROUNDING);
 998   u5 = _mm_add_epi32(v5, k__DCT_CONST_ROUNDING);
 999   u6 = _mm_add_epi32(v6, k__DCT_CONST_ROUNDING);
1000   u7 = _mm_add_epi32(v7, k__DCT_CONST_ROUNDING);
1001
1002   v0 = _mm_srai_epi32(u0, DCT_CONST_BITS);
1003   v1 = _mm_srai_epi32(u1, DCT_CONST_BITS);
1004   v2 = _mm_srai_epi32(u2, DCT_CONST_BITS);
1005   v3 = _mm_srai_epi32(u3, DCT_CONST_BITS);
1006   v4 = _mm_srai_epi32(u4, DCT_CONST_BITS);
1007   v5 = _mm_srai_epi32(u5, DCT_CONST_BITS);
1008   v6 = _mm_srai_epi32(u6, DCT_CONST_BITS);
1009   v7 = _mm_srai_epi32(u7, DCT_CONST_BITS);
1010
1011   s2 = _mm_packs_epi32(v0, v1);
1012   s3 = _mm_packs_epi32(v2, v3);
1013   s6 = _mm_packs_epi32(v4, v5);
1014   s7 = _mm_packs_epi32(v6, v7);
1015
1016   // FIXME(jingning): do subtract using bit inversion?
1017   in[0] = s0;
1018   in[1] = _mm_sub_epi16(k__const_0, s4);
1019   in[2] = s6;
1020   in[3] = _mm_sub_epi16(k__const_0, s2);
1021   in[4] = s3;
1022   in[5] = _mm_sub_epi16(k__const_0, s7);
1023   in[6] = s5;
1024   in[7] = _mm_sub_epi16(k__const_0, s1);
1025
1026   // transpose
1027   array_transpose_8x8(in, in);
1028 }
1029
1030 void vp9_short_fht8x8_sse2(const int16_t *input, int16_t *output,
1031                            int stride, int tx_type) {
1032   __m128i in[8];
1033   load_buffer_8x8(input, in, stride);
1034   switch (tx_type) {
1035     case 0:  // DCT_DCT
1036       fdct8_1d_sse2(in);
1037       fdct8_1d_sse2(in);
1038       break;
1039     case 1:  // ADST_DCT
1040       fadst8_1d_sse2(in);
1041       fdct8_1d_sse2(in);
1042       break;
1043     case 2:  // DCT_ADST
1044       fdct8_1d_sse2(in);
1045       fadst8_1d_sse2(in);
1046       break;
1047     case 3:  // ADST_ADST
1048       fadst8_1d_sse2(in);
1049       fadst8_1d_sse2(in);
1050       break;
1051     default:
1052       assert(0);
1053       break;
1054   }
1055   right_shift_8x8(in, 1);
1056   write_buffer_8x8(output, in, 8);
1057 }
1058
1059 void vp9_fdct16x16_sse2(const int16_t *input, int16_t *output, int stride) {
1060   // The 2D transform is done with two passes which are actually pretty
1061   // similar. In the first one, we transform the columns and transpose
1062   // the results. In the second one, we transform the rows. To achieve that,
1063   // as the first pass results are transposed, we tranpose the columns (that
1064   // is the transposed rows) and transpose the results (so that it goes back
1065   // in normal/row positions).
1066   int pass;
1067   // We need an intermediate buffer between passes.
1068   DECLARE_ALIGNED_ARRAY(16, int16_t, intermediate, 256);
1069   const int16_t *in = input;
1070   int16_t *out = intermediate;
1071   // Constants
1072   //    When we use them, in one case, they are all the same. In all others
1073   //    it's a pair of them that we need to repeat four times. This is done
1074   //    by constructing the 32 bit constant corresponding to that pair.
1075   const __m128i k__cospi_p16_p16 = _mm_set1_epi16(cospi_16_64);
1076   const __m128i k__cospi_p16_m16 = pair_set_epi16(cospi_16_64, -cospi_16_64);
1077   const __m128i k__cospi_p24_p08 = pair_set_epi16(cospi_24_64, cospi_8_64);
1078   const __m128i k__cospi_m24_m08 = pair_set_epi16(-cospi_24_64, -cospi_8_64);
1079   const __m128i k__cospi_m08_p24 = pair_set_epi16(-cospi_8_64, cospi_24_64);
1080   const __m128i k__cospi_p28_p04 = pair_set_epi16(cospi_28_64, cospi_4_64);
1081   const __m128i k__cospi_m04_p28 = pair_set_epi16(-cospi_4_64, cospi_28_64);
1082   const __m128i k__cospi_p12_p20 = pair_set_epi16(cospi_12_64, cospi_20_64);
1083   const __m128i k__cospi_m20_p12 = pair_set_epi16(-cospi_20_64, cospi_12_64);
1084   const __m128i k__cospi_p30_p02 = pair_set_epi16(cospi_30_64, cospi_2_64);
1085   const __m128i k__cospi_p14_p18 = pair_set_epi16(cospi_14_64, cospi_18_64);
1086   const __m128i k__cospi_m02_p30 = pair_set_epi16(-cospi_2_64, cospi_30_64);
1087   const __m128i k__cospi_m18_p14 = pair_set_epi16(-cospi_18_64, cospi_14_64);
1088   const __m128i k__cospi_p22_p10 = pair_set_epi16(cospi_22_64, cospi_10_64);
1089   const __m128i k__cospi_p06_p26 = pair_set_epi16(cospi_6_64, cospi_26_64);
1090   const __m128i k__cospi_m10_p22 = pair_set_epi16(-cospi_10_64, cospi_22_64);
1091   const __m128i k__cospi_m26_p06 = pair_set_epi16(-cospi_26_64, cospi_6_64);
1092   const __m128i k__DCT_CONST_ROUNDING = _mm_set1_epi32(DCT_CONST_ROUNDING);
1093   const __m128i kOne = _mm_set1_epi16(1);
1094   // Do the two transform/transpose passes
1095   for (pass = 0; pass < 2; ++pass) {
1096     // We process eight columns (transposed rows in second pass) at a time.
1097     int column_start;
1098     for (column_start = 0; column_start < 16; column_start += 8) {
1099       __m128i in00, in01, in02, in03, in04, in05, in06, in07;
1100       __m128i in08, in09, in10, in11, in12, in13, in14, in15;
1101       __m128i input0, input1, input2, input3, input4, input5, input6, input7;
1102       __m128i step1_0, step1_1, step1_2, step1_3;
1103       __m128i step1_4, step1_5, step1_6, step1_7;
1104       __m128i step2_1, step2_2, step2_3, step2_4, step2_5, step2_6;
1105       __m128i step3_0, step3_1, step3_2, step3_3;
1106       __m128i step3_4, step3_5, step3_6, step3_7;
1107       __m128i res00, res01, res02, res03, res04, res05, res06, res07;
1108       __m128i res08, res09, res10, res11, res12, res13, res14, res15;
1109       // Load and pre-condition input.
1110       if (0 == pass) {
1111         in00  = _mm_load_si128((const __m128i *)(in +  0 * stride));
1112         in01  = _mm_load_si128((const __m128i *)(in +  1 * stride));
1113         in02  = _mm_load_si128((const __m128i *)(in +  2 * stride));
1114         in03  = _mm_load_si128((const __m128i *)(in +  3 * stride));
1115         in04  = _mm_load_si128((const __m128i *)(in +  4 * stride));
1116         in05  = _mm_load_si128((const __m128i *)(in +  5 * stride));
1117         in06  = _mm_load_si128((const __m128i *)(in +  6 * stride));
1118         in07  = _mm_load_si128((const __m128i *)(in +  7 * stride));
1119         in08  = _mm_load_si128((const __m128i *)(in +  8 * stride));
1120         in09  = _mm_load_si128((const __m128i *)(in +  9 * stride));
1121         in10  = _mm_load_si128((const __m128i *)(in + 10 * stride));
1122         in11  = _mm_load_si128((const __m128i *)(in + 11 * stride));
1123         in12  = _mm_load_si128((const __m128i *)(in + 12 * stride));
1124         in13  = _mm_load_si128((const __m128i *)(in + 13 * stride));
1125         in14  = _mm_load_si128((const __m128i *)(in + 14 * stride));
1126         in15  = _mm_load_si128((const __m128i *)(in + 15 * stride));
1127         // x = x << 2
1128         in00 = _mm_slli_epi16(in00, 2);
1129         in01 = _mm_slli_epi16(in01, 2);
1130         in02 = _mm_slli_epi16(in02, 2);
1131         in03 = _mm_slli_epi16(in03, 2);
1132         in04 = _mm_slli_epi16(in04, 2);
1133         in05 = _mm_slli_epi16(in05, 2);
1134         in06 = _mm_slli_epi16(in06, 2);
1135         in07 = _mm_slli_epi16(in07, 2);
1136         in08 = _mm_slli_epi16(in08, 2);
1137         in09 = _mm_slli_epi16(in09, 2);
1138         in10 = _mm_slli_epi16(in10, 2);
1139         in11 = _mm_slli_epi16(in11, 2);
1140         in12 = _mm_slli_epi16(in12, 2);
1141         in13 = _mm_slli_epi16(in13, 2);
1142         in14 = _mm_slli_epi16(in14, 2);
1143         in15 = _mm_slli_epi16(in15, 2);
1144       } else {
1145         in00  = _mm_load_si128((const __m128i *)(in +  0 * 16));
1146         in01  = _mm_load_si128((const __m128i *)(in +  1 * 16));
1147         in02  = _mm_load_si128((const __m128i *)(in +  2 * 16));
1148         in03  = _mm_load_si128((const __m128i *)(in +  3 * 16));
1149         in04  = _mm_load_si128((const __m128i *)(in +  4 * 16));
1150         in05  = _mm_load_si128((const __m128i *)(in +  5 * 16));
1151         in06  = _mm_load_si128((const __m128i *)(in +  6 * 16));
1152         in07  = _mm_load_si128((const __m128i *)(in +  7 * 16));
1153         in08  = _mm_load_si128((const __m128i *)(in +  8 * 16));
1154         in09  = _mm_load_si128((const __m128i *)(in +  9 * 16));
1155         in10  = _mm_load_si128((const __m128i *)(in + 10 * 16));
1156         in11  = _mm_load_si128((const __m128i *)(in + 11 * 16));
1157         in12  = _mm_load_si128((const __m128i *)(in + 12 * 16));
1158         in13  = _mm_load_si128((const __m128i *)(in + 13 * 16));
1159         in14  = _mm_load_si128((const __m128i *)(in + 14 * 16));
1160         in15  = _mm_load_si128((const __m128i *)(in + 15 * 16));
1161         // x = (x + 1) >> 2
1162         in00 = _mm_add_epi16(in00, kOne);
1163         in01 = _mm_add_epi16(in01, kOne);
1164         in02 = _mm_add_epi16(in02, kOne);
1165         in03 = _mm_add_epi16(in03, kOne);
1166         in04 = _mm_add_epi16(in04, kOne);
1167         in05 = _mm_add_epi16(in05, kOne);
1168         in06 = _mm_add_epi16(in06, kOne);
1169         in07 = _mm_add_epi16(in07, kOne);
1170         in08 = _mm_add_epi16(in08, kOne);
1171         in09 = _mm_add_epi16(in09, kOne);
1172         in10 = _mm_add_epi16(in10, kOne);
1173         in11 = _mm_add_epi16(in11, kOne);
1174         in12 = _mm_add_epi16(in12, kOne);
1175         in13 = _mm_add_epi16(in13, kOne);
1176         in14 = _mm_add_epi16(in14, kOne);
1177         in15 = _mm_add_epi16(in15, kOne);
1178         in00 = _mm_srai_epi16(in00, 2);
1179         in01 = _mm_srai_epi16(in01, 2);
1180         in02 = _mm_srai_epi16(in02, 2);
1181         in03 = _mm_srai_epi16(in03, 2);
1182         in04 = _mm_srai_epi16(in04, 2);
1183         in05 = _mm_srai_epi16(in05, 2);
1184         in06 = _mm_srai_epi16(in06, 2);
1185         in07 = _mm_srai_epi16(in07, 2);
1186         in08 = _mm_srai_epi16(in08, 2);
1187         in09 = _mm_srai_epi16(in09, 2);
1188         in10 = _mm_srai_epi16(in10, 2);
1189         in11 = _mm_srai_epi16(in11, 2);
1190         in12 = _mm_srai_epi16(in12, 2);
1191         in13 = _mm_srai_epi16(in13, 2);
1192         in14 = _mm_srai_epi16(in14, 2);
1193         in15 = _mm_srai_epi16(in15, 2);
1194       }
1195       in += 8;
1196       // Calculate input for the first 8 results.
1197       {
1198         input0 = _mm_add_epi16(in00, in15);
1199         input1 = _mm_add_epi16(in01, in14);
1200         input2 = _mm_add_epi16(in02, in13);
1201         input3 = _mm_add_epi16(in03, in12);
1202         input4 = _mm_add_epi16(in04, in11);
1203         input5 = _mm_add_epi16(in05, in10);
1204         input6 = _mm_add_epi16(in06, in09);
1205         input7 = _mm_add_epi16(in07, in08);
1206       }
1207       // Calculate input for the next 8 results.
1208       {
1209         step1_0 = _mm_sub_epi16(in07, in08);
1210         step1_1 = _mm_sub_epi16(in06, in09);
1211         step1_2 = _mm_sub_epi16(in05, in10);
1212         step1_3 = _mm_sub_epi16(in04, in11);
1213         step1_4 = _mm_sub_epi16(in03, in12);
1214         step1_5 = _mm_sub_epi16(in02, in13);
1215         step1_6 = _mm_sub_epi16(in01, in14);
1216         step1_7 = _mm_sub_epi16(in00, in15);
1217       }
1218       // Work on the first eight values; fdct8_1d(input, even_results);
1219       {
1220         // Add/substract
1221         const __m128i q0 = _mm_add_epi16(input0, input7);
1222         const __m128i q1 = _mm_add_epi16(input1, input6);
1223         const __m128i q2 = _mm_add_epi16(input2, input5);
1224         const __m128i q3 = _mm_add_epi16(input3, input4);
1225         const __m128i q4 = _mm_sub_epi16(input3, input4);
1226         const __m128i q5 = _mm_sub_epi16(input2, input5);
1227         const __m128i q6 = _mm_sub_epi16(input1, input6);
1228         const __m128i q7 = _mm_sub_epi16(input0, input7);
1229         // Work on first four results
1230         {
1231           // Add/substract
1232           const __m128i r0 = _mm_add_epi16(q0, q3);
1233           const __m128i r1 = _mm_add_epi16(q1, q2);
1234           const __m128i r2 = _mm_sub_epi16(q1, q2);
1235           const __m128i r3 = _mm_sub_epi16(q0, q3);
1236           // Interleave to do the multiply by constants which gets us
1237           // into 32 bits.
1238           const __m128i t0 = _mm_unpacklo_epi16(r0, r1);
1239           const __m128i t1 = _mm_unpackhi_epi16(r0, r1);
1240           const __m128i t2 = _mm_unpacklo_epi16(r2, r3);
1241           const __m128i t3 = _mm_unpackhi_epi16(r2, r3);
1242           const __m128i u0 = _mm_madd_epi16(t0, k__cospi_p16_p16);
1243           const __m128i u1 = _mm_madd_epi16(t1, k__cospi_p16_p16);
1244           const __m128i u2 = _mm_madd_epi16(t0, k__cospi_p16_m16);
1245           const __m128i u3 = _mm_madd_epi16(t1, k__cospi_p16_m16);
1246           const __m128i u4 = _mm_madd_epi16(t2, k__cospi_p24_p08);
1247           const __m128i u5 = _mm_madd_epi16(t3, k__cospi_p24_p08);
1248           const __m128i u6 = _mm_madd_epi16(t2, k__cospi_m08_p24);
1249           const __m128i u7 = _mm_madd_epi16(t3, k__cospi_m08_p24);
1250           // dct_const_round_shift
1251           const __m128i v0 = _mm_add_epi32(u0, k__DCT_CONST_ROUNDING);
1252           const __m128i v1 = _mm_add_epi32(u1, k__DCT_CONST_ROUNDING);
1253           const __m128i v2 = _mm_add_epi32(u2, k__DCT_CONST_ROUNDING);
1254           const __m128i v3 = _mm_add_epi32(u3, k__DCT_CONST_ROUNDING);
1255           const __m128i v4 = _mm_add_epi32(u4, k__DCT_CONST_ROUNDING);
1256           const __m128i v5 = _mm_add_epi32(u5, k__DCT_CONST_ROUNDING);
1257           const __m128i v6 = _mm_add_epi32(u6, k__DCT_CONST_ROUNDING);
1258           const __m128i v7 = _mm_add_epi32(u7, k__DCT_CONST_ROUNDING);
1259           const __m128i w0 = _mm_srai_epi32(v0, DCT_CONST_BITS);
1260           const __m128i w1 = _mm_srai_epi32(v1, DCT_CONST_BITS);
1261           const __m128i w2 = _mm_srai_epi32(v2, DCT_CONST_BITS);
1262           const __m128i w3 = _mm_srai_epi32(v3, DCT_CONST_BITS);
1263           const __m128i w4 = _mm_srai_epi32(v4, DCT_CONST_BITS);
1264           const __m128i w5 = _mm_srai_epi32(v5, DCT_CONST_BITS);
1265           const __m128i w6 = _mm_srai_epi32(v6, DCT_CONST_BITS);
1266           const __m128i w7 = _mm_srai_epi32(v7, DCT_CONST_BITS);
1267           // Combine
1268           res00 = _mm_packs_epi32(w0, w1);
1269           res08 = _mm_packs_epi32(w2, w3);
1270           res04 = _mm_packs_epi32(w4, w5);
1271           res12 = _mm_packs_epi32(w6, w7);
1272         }
1273         // Work on next four results
1274         {
1275           // Interleave to do the multiply by constants which gets us
1276           // into 32 bits.
1277           const __m128i d0 = _mm_unpacklo_epi16(q6, q5);
1278           const __m128i d1 = _mm_unpackhi_epi16(q6, q5);
1279           const __m128i e0 = _mm_madd_epi16(d0, k__cospi_p16_m16);
1280           const __m128i e1 = _mm_madd_epi16(d1, k__cospi_p16_m16);
1281           const __m128i e2 = _mm_madd_epi16(d0, k__cospi_p16_p16);
1282           const __m128i e3 = _mm_madd_epi16(d1, k__cospi_p16_p16);
1283           // dct_const_round_shift
1284           const __m128i f0 = _mm_add_epi32(e0, k__DCT_CONST_ROUNDING);
1285           const __m128i f1 = _mm_add_epi32(e1, k__DCT_CONST_ROUNDING);
1286           const __m128i f2 = _mm_add_epi32(e2, k__DCT_CONST_ROUNDING);
1287           const __m128i f3 = _mm_add_epi32(e3, k__DCT_CONST_ROUNDING);
1288           const __m128i s0 = _mm_srai_epi32(f0, DCT_CONST_BITS);
1289           const __m128i s1 = _mm_srai_epi32(f1, DCT_CONST_BITS);
1290           const __m128i s2 = _mm_srai_epi32(f2, DCT_CONST_BITS);
1291           const __m128i s3 = _mm_srai_epi32(f3, DCT_CONST_BITS);
1292           // Combine
1293           const __m128i r0 = _mm_packs_epi32(s0, s1);
1294           const __m128i r1 = _mm_packs_epi32(s2, s3);
1295           // Add/substract
1296           const __m128i x0 = _mm_add_epi16(q4, r0);
1297           const __m128i x1 = _mm_sub_epi16(q4, r0);
1298           const __m128i x2 = _mm_sub_epi16(q7, r1);
1299           const __m128i x3 = _mm_add_epi16(q7, r1);
1300           // Interleave to do the multiply by constants which gets us
1301           // into 32 bits.
1302           const __m128i t0 = _mm_unpacklo_epi16(x0, x3);
1303           const __m128i t1 = _mm_unpackhi_epi16(x0, x3);
1304           const __m128i t2 = _mm_unpacklo_epi16(x1, x2);
1305           const __m128i t3 = _mm_unpackhi_epi16(x1, x2);
1306           const __m128i u0 = _mm_madd_epi16(t0, k__cospi_p28_p04);
1307           const __m128i u1 = _mm_madd_epi16(t1, k__cospi_p28_p04);
1308           const __m128i u2 = _mm_madd_epi16(t0, k__cospi_m04_p28);
1309           const __m128i u3 = _mm_madd_epi16(t1, k__cospi_m04_p28);
1310           const __m128i u4 = _mm_madd_epi16(t2, k__cospi_p12_p20);
1311           const __m128i u5 = _mm_madd_epi16(t3, k__cospi_p12_p20);
1312           const __m128i u6 = _mm_madd_epi16(t2, k__cospi_m20_p12);
1313           const __m128i u7 = _mm_madd_epi16(t3, k__cospi_m20_p12);
1314           // dct_const_round_shift
1315           const __m128i v0 = _mm_add_epi32(u0, k__DCT_CONST_ROUNDING);
1316           const __m128i v1 = _mm_add_epi32(u1, k__DCT_CONST_ROUNDING);
1317           const __m128i v2 = _mm_add_epi32(u2, k__DCT_CONST_ROUNDING);
1318           const __m128i v3 = _mm_add_epi32(u3, k__DCT_CONST_ROUNDING);
1319           const __m128i v4 = _mm_add_epi32(u4, k__DCT_CONST_ROUNDING);
1320           const __m128i v5 = _mm_add_epi32(u5, k__DCT_CONST_ROUNDING);
1321           const __m128i v6 = _mm_add_epi32(u6, k__DCT_CONST_ROUNDING);
1322           const __m128i v7 = _mm_add_epi32(u7, k__DCT_CONST_ROUNDING);
1323           const __m128i w0 = _mm_srai_epi32(v0, DCT_CONST_BITS);
1324           const __m128i w1 = _mm_srai_epi32(v1, DCT_CONST_BITS);
1325           const __m128i w2 = _mm_srai_epi32(v2, DCT_CONST_BITS);
1326           const __m128i w3 = _mm_srai_epi32(v3, DCT_CONST_BITS);
1327           const __m128i w4 = _mm_srai_epi32(v4, DCT_CONST_BITS);
1328           const __m128i w5 = _mm_srai_epi32(v5, DCT_CONST_BITS);
1329           const __m128i w6 = _mm_srai_epi32(v6, DCT_CONST_BITS);
1330           const __m128i w7 = _mm_srai_epi32(v7, DCT_CONST_BITS);
1331           // Combine
1332           res02 = _mm_packs_epi32(w0, w1);
1333           res14 = _mm_packs_epi32(w2, w3);
1334           res10 = _mm_packs_epi32(w4, w5);
1335           res06 = _mm_packs_epi32(w6, w7);
1336         }
1337       }
1338       // Work on the next eight values; step1 -> odd_results
1339       {
1340         // step 2
1341         {
1342           const __m128i t0 = _mm_unpacklo_epi16(step1_5, step1_2);
1343           const __m128i t1 = _mm_unpackhi_epi16(step1_5, step1_2);
1344           const __m128i t2 = _mm_unpacklo_epi16(step1_4, step1_3);
1345           const __m128i t3 = _mm_unpackhi_epi16(step1_4, step1_3);
1346           const __m128i u0 = _mm_madd_epi16(t0, k__cospi_p16_m16);
1347           const __m128i u1 = _mm_madd_epi16(t1, k__cospi_p16_m16);
1348           const __m128i u2 = _mm_madd_epi16(t2, k__cospi_p16_m16);
1349           const __m128i u3 = _mm_madd_epi16(t3, k__cospi_p16_m16);
1350           // dct_const_round_shift
1351           const __m128i v0 = _mm_add_epi32(u0, k__DCT_CONST_ROUNDING);
1352           const __m128i v1 = _mm_add_epi32(u1, k__DCT_CONST_ROUNDING);
1353           const __m128i v2 = _mm_add_epi32(u2, k__DCT_CONST_ROUNDING);
1354           const __m128i v3 = _mm_add_epi32(u3, k__DCT_CONST_ROUNDING);
1355           const __m128i w0 = _mm_srai_epi32(v0, DCT_CONST_BITS);
1356           const __m128i w1 = _mm_srai_epi32(v1, DCT_CONST_BITS);
1357           const __m128i w2 = _mm_srai_epi32(v2, DCT_CONST_BITS);
1358           const __m128i w3 = _mm_srai_epi32(v3, DCT_CONST_BITS);
1359           // Combine
1360           step2_2 = _mm_packs_epi32(w0, w1);
1361           step2_3 = _mm_packs_epi32(w2, w3);
1362         }
1363         {
1364           const __m128i t0 = _mm_unpacklo_epi16(step1_5, step1_2);
1365           const __m128i t1 = _mm_unpackhi_epi16(step1_5, step1_2);
1366           const __m128i t2 = _mm_unpacklo_epi16(step1_4, step1_3);
1367           const __m128i t3 = _mm_unpackhi_epi16(step1_4, step1_3);
1368           const __m128i u0 = _mm_madd_epi16(t0, k__cospi_p16_p16);
1369           const __m128i u1 = _mm_madd_epi16(t1, k__cospi_p16_p16);
1370           const __m128i u2 = _mm_madd_epi16(t2, k__cospi_p16_p16);
1371           const __m128i u3 = _mm_madd_epi16(t3, k__cospi_p16_p16);
1372           // dct_const_round_shift
1373           const __m128i v0 = _mm_add_epi32(u0, k__DCT_CONST_ROUNDING);
1374           const __m128i v1 = _mm_add_epi32(u1, k__DCT_CONST_ROUNDING);
1375           const __m128i v2 = _mm_add_epi32(u2, k__DCT_CONST_ROUNDING);
1376           const __m128i v3 = _mm_add_epi32(u3, k__DCT_CONST_ROUNDING);
1377           const __m128i w0 = _mm_srai_epi32(v0, DCT_CONST_BITS);
1378           const __m128i w1 = _mm_srai_epi32(v1, DCT_CONST_BITS);
1379           const __m128i w2 = _mm_srai_epi32(v2, DCT_CONST_BITS);
1380           const __m128i w3 = _mm_srai_epi32(v3, DCT_CONST_BITS);
1381           // Combine
1382           step2_5 = _mm_packs_epi32(w0, w1);
1383           step2_4 = _mm_packs_epi32(w2, w3);
1384         }
1385         // step 3
1386         {
1387           step3_0 = _mm_add_epi16(step1_0, step2_3);
1388           step3_1 = _mm_add_epi16(step1_1, step2_2);
1389           step3_2 = _mm_sub_epi16(step1_1, step2_2);
1390           step3_3 = _mm_sub_epi16(step1_0, step2_3);
1391           step3_4 = _mm_sub_epi16(step1_7, step2_4);
1392           step3_5 = _mm_sub_epi16(step1_6, step2_5);
1393           step3_6 = _mm_add_epi16(step1_6, step2_5);
1394           step3_7 = _mm_add_epi16(step1_7, step2_4);
1395         }
1396         // step 4
1397         {
1398           const __m128i t0 = _mm_unpacklo_epi16(step3_1, step3_6);
1399           const __m128i t1 = _mm_unpackhi_epi16(step3_1, step3_6);
1400           const __m128i t2 = _mm_unpacklo_epi16(step3_2, step3_5);
1401           const __m128i t3 = _mm_unpackhi_epi16(step3_2, step3_5);
1402           const __m128i u0 = _mm_madd_epi16(t0, k__cospi_m08_p24);
1403           const __m128i u1 = _mm_madd_epi16(t1, k__cospi_m08_p24);
1404           const __m128i u2 = _mm_madd_epi16(t2, k__cospi_m24_m08);
1405           const __m128i u3 = _mm_madd_epi16(t3, k__cospi_m24_m08);
1406           // dct_const_round_shift
1407           const __m128i v0 = _mm_add_epi32(u0, k__DCT_CONST_ROUNDING);
1408           const __m128i v1 = _mm_add_epi32(u1, k__DCT_CONST_ROUNDING);
1409           const __m128i v2 = _mm_add_epi32(u2, k__DCT_CONST_ROUNDING);
1410           const __m128i v3 = _mm_add_epi32(u3, k__DCT_CONST_ROUNDING);
1411           const __m128i w0 = _mm_srai_epi32(v0, DCT_CONST_BITS);
1412           const __m128i w1 = _mm_srai_epi32(v1, DCT_CONST_BITS);
1413           const __m128i w2 = _mm_srai_epi32(v2, DCT_CONST_BITS);
1414           const __m128i w3 = _mm_srai_epi32(v3, DCT_CONST_BITS);
1415           // Combine
1416           step2_1 = _mm_packs_epi32(w0, w1);
1417           step2_2 = _mm_packs_epi32(w2, w3);
1418         }
1419         {
1420           const __m128i t0 = _mm_unpacklo_epi16(step3_1, step3_6);
1421           const __m128i t1 = _mm_unpackhi_epi16(step3_1, step3_6);
1422           const __m128i t2 = _mm_unpacklo_epi16(step3_2, step3_5);
1423           const __m128i t3 = _mm_unpackhi_epi16(step3_2, step3_5);
1424           const __m128i u0 = _mm_madd_epi16(t0, k__cospi_p24_p08);
1425           const __m128i u1 = _mm_madd_epi16(t1, k__cospi_p24_p08);
1426           const __m128i u2 = _mm_madd_epi16(t2, k__cospi_m08_p24);
1427           const __m128i u3 = _mm_madd_epi16(t3, k__cospi_m08_p24);
1428           // dct_const_round_shift
1429           const __m128i v0 = _mm_add_epi32(u0, k__DCT_CONST_ROUNDING);
1430           const __m128i v1 = _mm_add_epi32(u1, k__DCT_CONST_ROUNDING);
1431           const __m128i v2 = _mm_add_epi32(u2, k__DCT_CONST_ROUNDING);
1432           const __m128i v3 = _mm_add_epi32(u3, k__DCT_CONST_ROUNDING);
1433           const __m128i w0 = _mm_srai_epi32(v0, DCT_CONST_BITS);
1434           const __m128i w1 = _mm_srai_epi32(v1, DCT_CONST_BITS);
1435           const __m128i w2 = _mm_srai_epi32(v2, DCT_CONST_BITS);
1436           const __m128i w3 = _mm_srai_epi32(v3, DCT_CONST_BITS);
1437           // Combine
1438           step2_6 = _mm_packs_epi32(w0, w1);
1439           step2_5 = _mm_packs_epi32(w2, w3);
1440         }
1441         // step 5
1442         {
1443           step1_0 = _mm_add_epi16(step3_0, step2_1);
1444           step1_1 = _mm_sub_epi16(step3_0, step2_1);
1445           step1_2 = _mm_sub_epi16(step3_3, step2_2);
1446           step1_3 = _mm_add_epi16(step3_3, step2_2);
1447           step1_4 = _mm_add_epi16(step3_4, step2_5);
1448           step1_5 = _mm_sub_epi16(step3_4, step2_5);
1449           step1_6 = _mm_sub_epi16(step3_7, step2_6);
1450           step1_7 = _mm_add_epi16(step3_7, step2_6);
1451         }
1452         // step 6
1453         {
1454           const __m128i t0 = _mm_unpacklo_epi16(step1_0, step1_7);
1455           const __m128i t1 = _mm_unpackhi_epi16(step1_0, step1_7);
1456           const __m128i t2 = _mm_unpacklo_epi16(step1_1, step1_6);
1457           const __m128i t3 = _mm_unpackhi_epi16(step1_1, step1_6);
1458           const __m128i u0 = _mm_madd_epi16(t0, k__cospi_p30_p02);
1459           const __m128i u1 = _mm_madd_epi16(t1, k__cospi_p30_p02);
1460           const __m128i u2 = _mm_madd_epi16(t2, k__cospi_p14_p18);
1461           const __m128i u3 = _mm_madd_epi16(t3, k__cospi_p14_p18);
1462           // dct_const_round_shift
1463           const __m128i v0 = _mm_add_epi32(u0, k__DCT_CONST_ROUNDING);
1464           const __m128i v1 = _mm_add_epi32(u1, k__DCT_CONST_ROUNDING);
1465           const __m128i v2 = _mm_add_epi32(u2, k__DCT_CONST_ROUNDING);
1466           const __m128i v3 = _mm_add_epi32(u3, k__DCT_CONST_ROUNDING);
1467           const __m128i w0 = _mm_srai_epi32(v0, DCT_CONST_BITS);
1468           const __m128i w1 = _mm_srai_epi32(v1, DCT_CONST_BITS);
1469           const __m128i w2 = _mm_srai_epi32(v2, DCT_CONST_BITS);
1470           const __m128i w3 = _mm_srai_epi32(v3, DCT_CONST_BITS);
1471           // Combine
1472           res01 = _mm_packs_epi32(w0, w1);
1473           res09 = _mm_packs_epi32(w2, w3);
1474         }
1475         {
1476           const __m128i t0 = _mm_unpacklo_epi16(step1_2, step1_5);
1477           const __m128i t1 = _mm_unpackhi_epi16(step1_2, step1_5);
1478           const __m128i t2 = _mm_unpacklo_epi16(step1_3, step1_4);
1479           const __m128i t3 = _mm_unpackhi_epi16(step1_3, step1_4);
1480           const __m128i u0 = _mm_madd_epi16(t0, k__cospi_p22_p10);
1481           const __m128i u1 = _mm_madd_epi16(t1, k__cospi_p22_p10);
1482           const __m128i u2 = _mm_madd_epi16(t2, k__cospi_p06_p26);
1483           const __m128i u3 = _mm_madd_epi16(t3, k__cospi_p06_p26);
1484           // dct_const_round_shift
1485           const __m128i v0 = _mm_add_epi32(u0, k__DCT_CONST_ROUNDING);
1486           const __m128i v1 = _mm_add_epi32(u1, k__DCT_CONST_ROUNDING);
1487           const __m128i v2 = _mm_add_epi32(u2, k__DCT_CONST_ROUNDING);
1488           const __m128i v3 = _mm_add_epi32(u3, k__DCT_CONST_ROUNDING);
1489           const __m128i w0 = _mm_srai_epi32(v0, DCT_CONST_BITS);
1490           const __m128i w1 = _mm_srai_epi32(v1, DCT_CONST_BITS);
1491           const __m128i w2 = _mm_srai_epi32(v2, DCT_CONST_BITS);
1492           const __m128i w3 = _mm_srai_epi32(v3, DCT_CONST_BITS);
1493           // Combine
1494           res05 = _mm_packs_epi32(w0, w1);
1495           res13 = _mm_packs_epi32(w2, w3);
1496         }
1497         {
1498           const __m128i t0 = _mm_unpacklo_epi16(step1_2, step1_5);
1499           const __m128i t1 = _mm_unpackhi_epi16(step1_2, step1_5);
1500           const __m128i t2 = _mm_unpacklo_epi16(step1_3, step1_4);
1501           const __m128i t3 = _mm_unpackhi_epi16(step1_3, step1_4);
1502           const __m128i u0 = _mm_madd_epi16(t0, k__cospi_m10_p22);
1503           const __m128i u1 = _mm_madd_epi16(t1, k__cospi_m10_p22);
1504           const __m128i u2 = _mm_madd_epi16(t2, k__cospi_m26_p06);
1505           const __m128i u3 = _mm_madd_epi16(t3, k__cospi_m26_p06);
1506           // dct_const_round_shift
1507           const __m128i v0 = _mm_add_epi32(u0, k__DCT_CONST_ROUNDING);
1508           const __m128i v1 = _mm_add_epi32(u1, k__DCT_CONST_ROUNDING);
1509           const __m128i v2 = _mm_add_epi32(u2, k__DCT_CONST_ROUNDING);
1510           const __m128i v3 = _mm_add_epi32(u3, k__DCT_CONST_ROUNDING);
1511           const __m128i w0 = _mm_srai_epi32(v0, DCT_CONST_BITS);
1512           const __m128i w1 = _mm_srai_epi32(v1, DCT_CONST_BITS);
1513           const __m128i w2 = _mm_srai_epi32(v2, DCT_CONST_BITS);
1514           const __m128i w3 = _mm_srai_epi32(v3, DCT_CONST_BITS);
1515           // Combine
1516           res11 = _mm_packs_epi32(w0, w1);
1517           res03 = _mm_packs_epi32(w2, w3);
1518         }
1519         {
1520           const __m128i t0 = _mm_unpacklo_epi16(step1_0, step1_7);
1521           const __m128i t1 = _mm_unpackhi_epi16(step1_0, step1_7);
1522           const __m128i t2 = _mm_unpacklo_epi16(step1_1, step1_6);
1523           const __m128i t3 = _mm_unpackhi_epi16(step1_1, step1_6);
1524           const __m128i u0 = _mm_madd_epi16(t0, k__cospi_m02_p30);
1525           const __m128i u1 = _mm_madd_epi16(t1, k__cospi_m02_p30);
1526           const __m128i u2 = _mm_madd_epi16(t2, k__cospi_m18_p14);
1527           const __m128i u3 = _mm_madd_epi16(t3, k__cospi_m18_p14);
1528           // dct_const_round_shift
1529           const __m128i v0 = _mm_add_epi32(u0, k__DCT_CONST_ROUNDING);
1530           const __m128i v1 = _mm_add_epi32(u1, k__DCT_CONST_ROUNDING);
1531           const __m128i v2 = _mm_add_epi32(u2, k__DCT_CONST_ROUNDING);
1532           const __m128i v3 = _mm_add_epi32(u3, k__DCT_CONST_ROUNDING);
1533           const __m128i w0 = _mm_srai_epi32(v0, DCT_CONST_BITS);
1534           const __m128i w1 = _mm_srai_epi32(v1, DCT_CONST_BITS);
1535           const __m128i w2 = _mm_srai_epi32(v2, DCT_CONST_BITS);
1536           const __m128i w3 = _mm_srai_epi32(v3, DCT_CONST_BITS);
1537           // Combine
1538           res15 = _mm_packs_epi32(w0, w1);
1539           res07 = _mm_packs_epi32(w2, w3);
1540         }
1541       }
1542       // Transpose the results, do it as two 8x8 transposes.
1543       {
1544         // 00 01 02 03 04 05 06 07
1545         // 10 11 12 13 14 15 16 17
1546         // 20 21 22 23 24 25 26 27
1547         // 30 31 32 33 34 35 36 37
1548         // 40 41 42 43 44 45 46 47
1549         // 50 51 52 53 54 55 56 57
1550         // 60 61 62 63 64 65 66 67
1551         // 70 71 72 73 74 75 76 77
1552         const __m128i tr0_0 = _mm_unpacklo_epi16(res00, res01);
1553         const __m128i tr0_1 = _mm_unpacklo_epi16(res02, res03);
1554         const __m128i tr0_2 = _mm_unpackhi_epi16(res00, res01);
1555         const __m128i tr0_3 = _mm_unpackhi_epi16(res02, res03);
1556         const __m128i tr0_4 = _mm_unpacklo_epi16(res04, res05);
1557         const __m128i tr0_5 = _mm_unpacklo_epi16(res06, res07);
1558         const __m128i tr0_6 = _mm_unpackhi_epi16(res04, res05);
1559         const __m128i tr0_7 = _mm_unpackhi_epi16(res06, res07);
1560         // 00 10 01 11 02 12 03 13
1561         // 20 30 21 31 22 32 23 33
1562         // 04 14 05 15 06 16 07 17
1563         // 24 34 25 35 26 36 27 37
1564         // 40 50 41 51 42 52 43 53
1565         // 60 70 61 71 62 72 63 73
1566         // 54 54 55 55 56 56 57 57
1567         // 64 74 65 75 66 76 67 77
1568         const __m128i tr1_0 = _mm_unpacklo_epi32(tr0_0, tr0_1);
1569         const __m128i tr1_1 = _mm_unpacklo_epi32(tr0_2, tr0_3);
1570         const __m128i tr1_2 = _mm_unpackhi_epi32(tr0_0, tr0_1);
1571         const __m128i tr1_3 = _mm_unpackhi_epi32(tr0_2, tr0_3);
1572         const __m128i tr1_4 = _mm_unpacklo_epi32(tr0_4, tr0_5);
1573         const __m128i tr1_5 = _mm_unpacklo_epi32(tr0_6, tr0_7);
1574         const __m128i tr1_6 = _mm_unpackhi_epi32(tr0_4, tr0_5);
1575         const __m128i tr1_7 = _mm_unpackhi_epi32(tr0_6, tr0_7);
1576         // 00 10 20 30 01 11 21 31
1577         // 40 50 60 70 41 51 61 71
1578         // 02 12 22 32 03 13 23 33
1579         // 42 52 62 72 43 53 63 73
1580         // 04 14 24 34 05 15 21 36
1581         // 44 54 64 74 45 55 61 76
1582         // 06 16 26 36 07 17 27 37
1583         // 46 56 66 76 47 57 67 77
1584         const __m128i tr2_0 = _mm_unpacklo_epi64(tr1_0, tr1_4);
1585         const __m128i tr2_1 = _mm_unpackhi_epi64(tr1_0, tr1_4);
1586         const __m128i tr2_2 = _mm_unpacklo_epi64(tr1_2, tr1_6);
1587         const __m128i tr2_3 = _mm_unpackhi_epi64(tr1_2, tr1_6);
1588         const __m128i tr2_4 = _mm_unpacklo_epi64(tr1_1, tr1_5);
1589         const __m128i tr2_5 = _mm_unpackhi_epi64(tr1_1, tr1_5);
1590         const __m128i tr2_6 = _mm_unpacklo_epi64(tr1_3, tr1_7);
1591         const __m128i tr2_7 = _mm_unpackhi_epi64(tr1_3, tr1_7);
1592         // 00 10 20 30 40 50 60 70
1593         // 01 11 21 31 41 51 61 71
1594         // 02 12 22 32 42 52 62 72
1595         // 03 13 23 33 43 53 63 73
1596         // 04 14 24 34 44 54 64 74
1597         // 05 15 25 35 45 55 65 75
1598         // 06 16 26 36 46 56 66 76
1599         // 07 17 27 37 47 57 67 77
1600         _mm_storeu_si128((__m128i *)(out + 0 * 16), tr2_0);
1601         _mm_storeu_si128((__m128i *)(out + 1 * 16), tr2_1);
1602         _mm_storeu_si128((__m128i *)(out + 2 * 16), tr2_2);
1603         _mm_storeu_si128((__m128i *)(out + 3 * 16), tr2_3);
1604         _mm_storeu_si128((__m128i *)(out + 4 * 16), tr2_4);
1605         _mm_storeu_si128((__m128i *)(out + 5 * 16), tr2_5);
1606         _mm_storeu_si128((__m128i *)(out + 6 * 16), tr2_6);
1607         _mm_storeu_si128((__m128i *)(out + 7 * 16), tr2_7);
1608       }
1609       {
1610         // 00 01 02 03 04 05 06 07
1611         // 10 11 12 13 14 15 16 17
1612         // 20 21 22 23 24 25 26 27
1613         // 30 31 32 33 34 35 36 37
1614         // 40 41 42 43 44 45 46 47
1615         // 50 51 52 53 54 55 56 57
1616         // 60 61 62 63 64 65 66 67
1617         // 70 71 72 73 74 75 76 77
1618         const __m128i tr0_0 = _mm_unpacklo_epi16(res08, res09);
1619         const __m128i tr0_1 = _mm_unpacklo_epi16(res10, res11);
1620         const __m128i tr0_2 = _mm_unpackhi_epi16(res08, res09);
1621         const __m128i tr0_3 = _mm_unpackhi_epi16(res10, res11);
1622         const __m128i tr0_4 = _mm_unpacklo_epi16(res12, res13);
1623         const __m128i tr0_5 = _mm_unpacklo_epi16(res14, res15);
1624         const __m128i tr0_6 = _mm_unpackhi_epi16(res12, res13);
1625         const __m128i tr0_7 = _mm_unpackhi_epi16(res14, res15);
1626         // 00 10 01 11 02 12 03 13
1627         // 20 30 21 31 22 32 23 33
1628         // 04 14 05 15 06 16 07 17
1629         // 24 34 25 35 26 36 27 37
1630         // 40 50 41 51 42 52 43 53
1631         // 60 70 61 71 62 72 63 73
1632         // 54 54 55 55 56 56 57 57
1633         // 64 74 65 75 66 76 67 77
1634         const __m128i tr1_0 = _mm_unpacklo_epi32(tr0_0, tr0_1);
1635         const __m128i tr1_1 = _mm_unpacklo_epi32(tr0_2, tr0_3);
1636         const __m128i tr1_2 = _mm_unpackhi_epi32(tr0_0, tr0_1);
1637         const __m128i tr1_3 = _mm_unpackhi_epi32(tr0_2, tr0_3);
1638         const __m128i tr1_4 = _mm_unpacklo_epi32(tr0_4, tr0_5);
1639         const __m128i tr1_5 = _mm_unpacklo_epi32(tr0_6, tr0_7);
1640         const __m128i tr1_6 = _mm_unpackhi_epi32(tr0_4, tr0_5);
1641         const __m128i tr1_7 = _mm_unpackhi_epi32(tr0_6, tr0_7);
1642         // 00 10 20 30 01 11 21 31
1643         // 40 50 60 70 41 51 61 71
1644         // 02 12 22 32 03 13 23 33
1645         // 42 52 62 72 43 53 63 73
1646         // 04 14 24 34 05 15 21 36
1647         // 44 54 64 74 45 55 61 76
1648         // 06 16 26 36 07 17 27 37
1649         // 46 56 66 76 47 57 67 77
1650         const __m128i tr2_0 = _mm_unpacklo_epi64(tr1_0, tr1_4);
1651         const __m128i tr2_1 = _mm_unpackhi_epi64(tr1_0, tr1_4);
1652         const __m128i tr2_2 = _mm_unpacklo_epi64(tr1_2, tr1_6);
1653         const __m128i tr2_3 = _mm_unpackhi_epi64(tr1_2, tr1_6);
1654         const __m128i tr2_4 = _mm_unpacklo_epi64(tr1_1, tr1_5);
1655         const __m128i tr2_5 = _mm_unpackhi_epi64(tr1_1, tr1_5);
1656         const __m128i tr2_6 = _mm_unpacklo_epi64(tr1_3, tr1_7);
1657         const __m128i tr2_7 = _mm_unpackhi_epi64(tr1_3, tr1_7);
1658         // 00 10 20 30 40 50 60 70
1659         // 01 11 21 31 41 51 61 71
1660         // 02 12 22 32 42 52 62 72
1661         // 03 13 23 33 43 53 63 73
1662         // 04 14 24 34 44 54 64 74
1663         // 05 15 25 35 45 55 65 75
1664         // 06 16 26 36 46 56 66 76
1665         // 07 17 27 37 47 57 67 77
1666         // Store results
1667         _mm_store_si128((__m128i *)(out + 8 + 0 * 16), tr2_0);
1668         _mm_store_si128((__m128i *)(out + 8 + 1 * 16), tr2_1);
1669         _mm_store_si128((__m128i *)(out + 8 + 2 * 16), tr2_2);
1670         _mm_store_si128((__m128i *)(out + 8 + 3 * 16), tr2_3);
1671         _mm_store_si128((__m128i *)(out + 8 + 4 * 16), tr2_4);
1672         _mm_store_si128((__m128i *)(out + 8 + 5 * 16), tr2_5);
1673         _mm_store_si128((__m128i *)(out + 8 + 6 * 16), tr2_6);
1674         _mm_store_si128((__m128i *)(out + 8 + 7 * 16), tr2_7);
1675       }
1676       out += 8*16;
1677     }
1678     // Setup in/out for next pass.
1679     in = intermediate;
1680     out = output;
1681   }
1682 }
1683
1684 static INLINE void load_buffer_16x16(const int16_t* input, __m128i *in0,
1685                                      __m128i *in1, int stride) {
1686   // load first 8 columns
1687   load_buffer_8x8(input, in0, stride);
1688   load_buffer_8x8(input + 8 * stride, in0 + 8, stride);
1689
1690   input += 8;
1691   // load second 8 columns
1692   load_buffer_8x8(input, in1, stride);
1693   load_buffer_8x8(input + 8 * stride, in1 + 8, stride);
1694 }
1695
1696 static INLINE void write_buffer_16x16(int16_t *output, __m128i *in0,
1697                                       __m128i *in1, int stride) {
1698   // write first 8 columns
1699   write_buffer_8x8(output, in0, stride);
1700   write_buffer_8x8(output + 8 * stride, in0 + 8, stride);
1701   // write second 8 columns
1702   output += 8;
1703   write_buffer_8x8(output, in1, stride);
1704   write_buffer_8x8(output + 8 * stride, in1 + 8, stride);
1705 }
1706
1707 static INLINE void array_transpose_16x16(__m128i *res0, __m128i *res1) {
1708   __m128i tbuf[8];
1709   array_transpose_8x8(res0, res0);
1710   array_transpose_8x8(res1, tbuf);
1711   array_transpose_8x8(res0 + 8, res1);
1712   array_transpose_8x8(res1 + 8, res1 + 8);
1713
1714   res0[8] = tbuf[0];
1715   res0[9] = tbuf[1];
1716   res0[10] = tbuf[2];
1717   res0[11] = tbuf[3];
1718   res0[12] = tbuf[4];
1719   res0[13] = tbuf[5];
1720   res0[14] = tbuf[6];
1721   res0[15] = tbuf[7];
1722 }
1723
1724 static INLINE void right_shift_16x16(__m128i *res0, __m128i *res1) {
1725   // perform rounding operations
1726   right_shift_8x8(res0, 2);
1727   right_shift_8x8(res0 + 8, 2);
1728   right_shift_8x8(res1, 2);
1729   right_shift_8x8(res1 + 8, 2);
1730 }
1731
1732 void fdct16_1d_8col(__m128i *in) {
1733   // perform 16x16 1-D DCT for 8 columns
1734   __m128i i[8], s[8], p[8], t[8], u[16], v[16];
1735   const __m128i k__cospi_p16_p16 = _mm_set1_epi16(cospi_16_64);
1736   const __m128i k__cospi_p16_m16 = pair_set_epi16(cospi_16_64, -cospi_16_64);
1737   const __m128i k__cospi_m16_p16 = pair_set_epi16(-cospi_16_64, cospi_16_64);
1738   const __m128i k__cospi_p24_p08 = pair_set_epi16(cospi_24_64, cospi_8_64);
1739   const __m128i k__cospi_m24_m08 = pair_set_epi16(-cospi_24_64, -cospi_8_64);
1740   const __m128i k__cospi_m08_p24 = pair_set_epi16(-cospi_8_64, cospi_24_64);
1741   const __m128i k__cospi_p28_p04 = pair_set_epi16(cospi_28_64, cospi_4_64);
1742   const __m128i k__cospi_m04_p28 = pair_set_epi16(-cospi_4_64, cospi_28_64);
1743   const __m128i k__cospi_p12_p20 = pair_set_epi16(cospi_12_64, cospi_20_64);
1744   const __m128i k__cospi_m20_p12 = pair_set_epi16(-cospi_20_64, cospi_12_64);
1745   const __m128i k__cospi_p30_p02 = pair_set_epi16(cospi_30_64, cospi_2_64);
1746   const __m128i k__cospi_p14_p18 = pair_set_epi16(cospi_14_64, cospi_18_64);
1747   const __m128i k__cospi_m02_p30 = pair_set_epi16(-cospi_2_64, cospi_30_64);
1748   const __m128i k__cospi_m18_p14 = pair_set_epi16(-cospi_18_64, cospi_14_64);
1749   const __m128i k__cospi_p22_p10 = pair_set_epi16(cospi_22_64, cospi_10_64);
1750   const __m128i k__cospi_p06_p26 = pair_set_epi16(cospi_6_64, cospi_26_64);
1751   const __m128i k__cospi_m10_p22 = pair_set_epi16(-cospi_10_64, cospi_22_64);
1752   const __m128i k__cospi_m26_p06 = pair_set_epi16(-cospi_26_64, cospi_6_64);
1753   const __m128i k__DCT_CONST_ROUNDING = _mm_set1_epi32(DCT_CONST_ROUNDING);
1754
1755   // stage 1
1756   i[0] = _mm_add_epi16(in[0], in[15]);
1757   i[1] = _mm_add_epi16(in[1], in[14]);
1758   i[2] = _mm_add_epi16(in[2], in[13]);
1759   i[3] = _mm_add_epi16(in[3], in[12]);
1760   i[4] = _mm_add_epi16(in[4], in[11]);
1761   i[5] = _mm_add_epi16(in[5], in[10]);
1762   i[6] = _mm_add_epi16(in[6], in[9]);
1763   i[7] = _mm_add_epi16(in[7], in[8]);
1764
1765   s[0] = _mm_sub_epi16(in[7], in[8]);
1766   s[1] = _mm_sub_epi16(in[6], in[9]);
1767   s[2] = _mm_sub_epi16(in[5], in[10]);
1768   s[3] = _mm_sub_epi16(in[4], in[11]);
1769   s[4] = _mm_sub_epi16(in[3], in[12]);
1770   s[5] = _mm_sub_epi16(in[2], in[13]);
1771   s[6] = _mm_sub_epi16(in[1], in[14]);
1772   s[7] = _mm_sub_epi16(in[0], in[15]);
1773
1774   p[0] = _mm_add_epi16(i[0], i[7]);
1775   p[1] = _mm_add_epi16(i[1], i[6]);
1776   p[2] = _mm_add_epi16(i[2], i[5]);
1777   p[3] = _mm_add_epi16(i[3], i[4]);
1778   p[4] = _mm_sub_epi16(i[3], i[4]);
1779   p[5] = _mm_sub_epi16(i[2], i[5]);
1780   p[6] = _mm_sub_epi16(i[1], i[6]);
1781   p[7] = _mm_sub_epi16(i[0], i[7]);
1782
1783   u[0] = _mm_add_epi16(p[0], p[3]);
1784   u[1] = _mm_add_epi16(p[1], p[2]);
1785   u[2] = _mm_sub_epi16(p[1], p[2]);
1786   u[3] = _mm_sub_epi16(p[0], p[3]);
1787
1788   v[0] = _mm_unpacklo_epi16(u[0], u[1]);
1789   v[1] = _mm_unpackhi_epi16(u[0], u[1]);
1790   v[2] = _mm_unpacklo_epi16(u[2], u[3]);
1791   v[3] = _mm_unpackhi_epi16(u[2], u[3]);
1792
1793   u[0] = _mm_madd_epi16(v[0], k__cospi_p16_p16);
1794   u[1] = _mm_madd_epi16(v[1], k__cospi_p16_p16);
1795   u[2] = _mm_madd_epi16(v[0], k__cospi_p16_m16);
1796   u[3] = _mm_madd_epi16(v[1], k__cospi_p16_m16);
1797   u[4] = _mm_madd_epi16(v[2], k__cospi_p24_p08);
1798   u[5] = _mm_madd_epi16(v[3], k__cospi_p24_p08);
1799   u[6] = _mm_madd_epi16(v[2], k__cospi_m08_p24);
1800   u[7] = _mm_madd_epi16(v[3], k__cospi_m08_p24);
1801
1802   v[0] = _mm_add_epi32(u[0], k__DCT_CONST_ROUNDING);
1803   v[1] = _mm_add_epi32(u[1], k__DCT_CONST_ROUNDING);
1804   v[2] = _mm_add_epi32(u[2], k__DCT_CONST_ROUNDING);
1805   v[3] = _mm_add_epi32(u[3], k__DCT_CONST_ROUNDING);
1806   v[4] = _mm_add_epi32(u[4], k__DCT_CONST_ROUNDING);
1807   v[5] = _mm_add_epi32(u[5], k__DCT_CONST_ROUNDING);
1808   v[6] = _mm_add_epi32(u[6], k__DCT_CONST_ROUNDING);
1809   v[7] = _mm_add_epi32(u[7], k__DCT_CONST_ROUNDING);
1810
1811   u[0] = _mm_srai_epi32(v[0], DCT_CONST_BITS);
1812   u[1] = _mm_srai_epi32(v[1], DCT_CONST_BITS);
1813   u[2] = _mm_srai_epi32(v[2], DCT_CONST_BITS);
1814   u[3] = _mm_srai_epi32(v[3], DCT_CONST_BITS);
1815   u[4] = _mm_srai_epi32(v[4], DCT_CONST_BITS);
1816   u[5] = _mm_srai_epi32(v[5], DCT_CONST_BITS);
1817   u[6] = _mm_srai_epi32(v[6], DCT_CONST_BITS);
1818   u[7] = _mm_srai_epi32(v[7], DCT_CONST_BITS);
1819
1820   in[0] = _mm_packs_epi32(u[0], u[1]);
1821   in[4] = _mm_packs_epi32(u[4], u[5]);
1822   in[8] = _mm_packs_epi32(u[2], u[3]);
1823   in[12] = _mm_packs_epi32(u[6], u[7]);
1824
1825   u[0] = _mm_unpacklo_epi16(p[5], p[6]);
1826   u[1] = _mm_unpackhi_epi16(p[5], p[6]);
1827   v[0] = _mm_madd_epi16(u[0], k__cospi_m16_p16);
1828   v[1] = _mm_madd_epi16(u[1], k__cospi_m16_p16);
1829   v[2] = _mm_madd_epi16(u[0], k__cospi_p16_p16);
1830   v[3] = _mm_madd_epi16(u[1], k__cospi_p16_p16);
1831
1832   u[0] = _mm_add_epi32(v[0], k__DCT_CONST_ROUNDING);
1833   u[1] = _mm_add_epi32(v[1], k__DCT_CONST_ROUNDING);
1834   u[2] = _mm_add_epi32(v[2], k__DCT_CONST_ROUNDING);
1835   u[3] = _mm_add_epi32(v[3], k__DCT_CONST_ROUNDING);
1836
1837   v[0] = _mm_srai_epi32(u[0], DCT_CONST_BITS);
1838   v[1] = _mm_srai_epi32(u[1], DCT_CONST_BITS);
1839   v[2] = _mm_srai_epi32(u[2], DCT_CONST_BITS);
1840   v[3] = _mm_srai_epi32(u[3], DCT_CONST_BITS);
1841
1842   u[0] = _mm_packs_epi32(v[0], v[1]);
1843   u[1] = _mm_packs_epi32(v[2], v[3]);
1844
1845   t[0] = _mm_add_epi16(p[4], u[0]);
1846   t[1] = _mm_sub_epi16(p[4], u[0]);
1847   t[2] = _mm_sub_epi16(p[7], u[1]);
1848   t[3] = _mm_add_epi16(p[7], u[1]);
1849
1850   u[0] = _mm_unpacklo_epi16(t[0], t[3]);
1851   u[1] = _mm_unpackhi_epi16(t[0], t[3]);
1852   u[2] = _mm_unpacklo_epi16(t[1], t[2]);
1853   u[3] = _mm_unpackhi_epi16(t[1], t[2]);
1854
1855   v[0] = _mm_madd_epi16(u[0], k__cospi_p28_p04);
1856   v[1] = _mm_madd_epi16(u[1], k__cospi_p28_p04);
1857   v[2] = _mm_madd_epi16(u[2], k__cospi_p12_p20);
1858   v[3] = _mm_madd_epi16(u[3], k__cospi_p12_p20);
1859   v[4] = _mm_madd_epi16(u[2], k__cospi_m20_p12);
1860   v[5] = _mm_madd_epi16(u[3], k__cospi_m20_p12);
1861   v[6] = _mm_madd_epi16(u[0], k__cospi_m04_p28);
1862   v[7] = _mm_madd_epi16(u[1], k__cospi_m04_p28);
1863
1864   u[0] = _mm_add_epi32(v[0], k__DCT_CONST_ROUNDING);
1865   u[1] = _mm_add_epi32(v[1], k__DCT_CONST_ROUNDING);
1866   u[2] = _mm_add_epi32(v[2], k__DCT_CONST_ROUNDING);
1867   u[3] = _mm_add_epi32(v[3], k__DCT_CONST_ROUNDING);
1868   u[4] = _mm_add_epi32(v[4], k__DCT_CONST_ROUNDING);
1869   u[5] = _mm_add_epi32(v[5], k__DCT_CONST_ROUNDING);
1870   u[6] = _mm_add_epi32(v[6], k__DCT_CONST_ROUNDING);
1871   u[7] = _mm_add_epi32(v[7], k__DCT_CONST_ROUNDING);
1872
1873   v[0] = _mm_srai_epi32(u[0], DCT_CONST_BITS);
1874   v[1] = _mm_srai_epi32(u[1], DCT_CONST_BITS);
1875   v[2] = _mm_srai_epi32(u[2], DCT_CONST_BITS);
1876   v[3] = _mm_srai_epi32(u[3], DCT_CONST_BITS);
1877   v[4] = _mm_srai_epi32(u[4], DCT_CONST_BITS);
1878   v[5] = _mm_srai_epi32(u[5], DCT_CONST_BITS);
1879   v[6] = _mm_srai_epi32(u[6], DCT_CONST_BITS);
1880   v[7] = _mm_srai_epi32(u[7], DCT_CONST_BITS);
1881
1882   in[2] = _mm_packs_epi32(v[0], v[1]);
1883   in[6] = _mm_packs_epi32(v[4], v[5]);
1884   in[10] = _mm_packs_epi32(v[2], v[3]);
1885   in[14] = _mm_packs_epi32(v[6], v[7]);
1886
1887   // stage 2
1888   u[0] = _mm_unpacklo_epi16(s[2], s[5]);
1889   u[1] = _mm_unpackhi_epi16(s[2], s[5]);
1890   u[2] = _mm_unpacklo_epi16(s[3], s[4]);
1891   u[3] = _mm_unpackhi_epi16(s[3], s[4]);
1892
1893   v[0] = _mm_madd_epi16(u[0], k__cospi_m16_p16);
1894   v[1] = _mm_madd_epi16(u[1], k__cospi_m16_p16);
1895   v[2] = _mm_madd_epi16(u[2], k__cospi_m16_p16);
1896   v[3] = _mm_madd_epi16(u[3], k__cospi_m16_p16);
1897   v[4] = _mm_madd_epi16(u[2], k__cospi_p16_p16);
1898   v[5] = _mm_madd_epi16(u[3], k__cospi_p16_p16);
1899   v[6] = _mm_madd_epi16(u[0], k__cospi_p16_p16);
1900   v[7] = _mm_madd_epi16(u[1], k__cospi_p16_p16);
1901
1902   u[0] = _mm_add_epi32(v[0], k__DCT_CONST_ROUNDING);
1903   u[1] = _mm_add_epi32(v[1], k__DCT_CONST_ROUNDING);
1904   u[2] = _mm_add_epi32(v[2], k__DCT_CONST_ROUNDING);
1905   u[3] = _mm_add_epi32(v[3], k__DCT_CONST_ROUNDING);
1906   u[4] = _mm_add_epi32(v[4], k__DCT_CONST_ROUNDING);
1907   u[5] = _mm_add_epi32(v[5], k__DCT_CONST_ROUNDING);
1908   u[6] = _mm_add_epi32(v[6], k__DCT_CONST_ROUNDING);
1909   u[7] = _mm_add_epi32(v[7], k__DCT_CONST_ROUNDING);
1910
1911   v[0] = _mm_srai_epi32(u[0], DCT_CONST_BITS);
1912   v[1] = _mm_srai_epi32(u[1], DCT_CONST_BITS);
1913   v[2] = _mm_srai_epi32(u[2], DCT_CONST_BITS);
1914   v[3] = _mm_srai_epi32(u[3], DCT_CONST_BITS);
1915   v[4] = _mm_srai_epi32(u[4], DCT_CONST_BITS);
1916   v[5] = _mm_srai_epi32(u[5], DCT_CONST_BITS);
1917   v[6] = _mm_srai_epi32(u[6], DCT_CONST_BITS);
1918   v[7] = _mm_srai_epi32(u[7], DCT_CONST_BITS);
1919
1920   t[2] = _mm_packs_epi32(v[0], v[1]);
1921   t[3] = _mm_packs_epi32(v[2], v[3]);
1922   t[4] = _mm_packs_epi32(v[4], v[5]);
1923   t[5] = _mm_packs_epi32(v[6], v[7]);
1924
1925   // stage 3
1926   p[0] = _mm_add_epi16(s[0], t[3]);
1927   p[1] = _mm_add_epi16(s[1], t[2]);
1928   p[2] = _mm_sub_epi16(s[1], t[2]);
1929   p[3] = _mm_sub_epi16(s[0], t[3]);
1930   p[4] = _mm_sub_epi16(s[7], t[4]);
1931   p[5] = _mm_sub_epi16(s[6], t[5]);
1932   p[6] = _mm_add_epi16(s[6], t[5]);
1933   p[7] = _mm_add_epi16(s[7], t[4]);
1934
1935   // stage 4
1936   u[0] = _mm_unpacklo_epi16(p[1], p[6]);
1937   u[1] = _mm_unpackhi_epi16(p[1], p[6]);
1938   u[2] = _mm_unpacklo_epi16(p[2], p[5]);
1939   u[3] = _mm_unpackhi_epi16(p[2], p[5]);
1940
1941   v[0] = _mm_madd_epi16(u[0], k__cospi_m08_p24);
1942   v[1] = _mm_madd_epi16(u[1], k__cospi_m08_p24);
1943   v[2] = _mm_madd_epi16(u[2], k__cospi_m24_m08);
1944   v[3] = _mm_madd_epi16(u[3], k__cospi_m24_m08);
1945   v[4] = _mm_madd_epi16(u[2], k__cospi_m08_p24);
1946   v[5] = _mm_madd_epi16(u[3], k__cospi_m08_p24);
1947   v[6] = _mm_madd_epi16(u[0], k__cospi_p24_p08);
1948   v[7] = _mm_madd_epi16(u[1], k__cospi_p24_p08);
1949
1950   u[0] = _mm_add_epi32(v[0], k__DCT_CONST_ROUNDING);
1951   u[1] = _mm_add_epi32(v[1], k__DCT_CONST_ROUNDING);
1952   u[2] = _mm_add_epi32(v[2], k__DCT_CONST_ROUNDING);
1953   u[3] = _mm_add_epi32(v[3], k__DCT_CONST_ROUNDING);
1954   u[4] = _mm_add_epi32(v[4], k__DCT_CONST_ROUNDING);
1955   u[5] = _mm_add_epi32(v[5], k__DCT_CONST_ROUNDING);
1956   u[6] = _mm_add_epi32(v[6], k__DCT_CONST_ROUNDING);
1957   u[7] = _mm_add_epi32(v[7], k__DCT_CONST_ROUNDING);
1958
1959   v[0] = _mm_srai_epi32(u[0], DCT_CONST_BITS);
1960   v[1] = _mm_srai_epi32(u[1], DCT_CONST_BITS);
1961   v[2] = _mm_srai_epi32(u[2], DCT_CONST_BITS);
1962   v[3] = _mm_srai_epi32(u[3], DCT_CONST_BITS);
1963   v[4] = _mm_srai_epi32(u[4], DCT_CONST_BITS);
1964   v[5] = _mm_srai_epi32(u[5], DCT_CONST_BITS);
1965   v[6] = _mm_srai_epi32(u[6], DCT_CONST_BITS);
1966   v[7] = _mm_srai_epi32(u[7], DCT_CONST_BITS);
1967
1968   t[1] = _mm_packs_epi32(v[0], v[1]);
1969   t[2] = _mm_packs_epi32(v[2], v[3]);
1970   t[5] = _mm_packs_epi32(v[4], v[5]);
1971   t[6] = _mm_packs_epi32(v[6], v[7]);
1972
1973   // stage 5
1974   s[0] = _mm_add_epi16(p[0], t[1]);
1975   s[1] = _mm_sub_epi16(p[0], t[1]);
1976   s[2] = _mm_sub_epi16(p[3], t[2]);
1977   s[3] = _mm_add_epi16(p[3], t[2]);
1978   s[4] = _mm_add_epi16(p[4], t[5]);
1979   s[5] = _mm_sub_epi16(p[4], t[5]);
1980   s[6] = _mm_sub_epi16(p[7], t[6]);
1981   s[7] = _mm_add_epi16(p[7], t[6]);
1982
1983   // stage 6
1984   u[0] = _mm_unpacklo_epi16(s[0], s[7]);
1985   u[1] = _mm_unpackhi_epi16(s[0], s[7]);
1986   u[2] = _mm_unpacklo_epi16(s[1], s[6]);
1987   u[3] = _mm_unpackhi_epi16(s[1], s[6]);
1988   u[4] = _mm_unpacklo_epi16(s[2], s[5]);
1989   u[5] = _mm_unpackhi_epi16(s[2], s[5]);
1990   u[6] = _mm_unpacklo_epi16(s[3], s[4]);
1991   u[7] = _mm_unpackhi_epi16(s[3], s[4]);
1992
1993   v[0] = _mm_madd_epi16(u[0], k__cospi_p30_p02);
1994   v[1] = _mm_madd_epi16(u[1], k__cospi_p30_p02);
1995   v[2] = _mm_madd_epi16(u[2], k__cospi_p14_p18);
1996   v[3] = _mm_madd_epi16(u[3], k__cospi_p14_p18);
1997   v[4] = _mm_madd_epi16(u[4], k__cospi_p22_p10);
1998   v[5] = _mm_madd_epi16(u[5], k__cospi_p22_p10);
1999   v[6] = _mm_madd_epi16(u[6], k__cospi_p06_p26);
2000   v[7] = _mm_madd_epi16(u[7], k__cospi_p06_p26);
2001   v[8] = _mm_madd_epi16(u[6], k__cospi_m26_p06);
2002   v[9] = _mm_madd_epi16(u[7], k__cospi_m26_p06);
2003   v[10] = _mm_madd_epi16(u[4], k__cospi_m10_p22);
2004   v[11] = _mm_madd_epi16(u[5], k__cospi_m10_p22);
2005   v[12] = _mm_madd_epi16(u[2], k__cospi_m18_p14);
2006   v[13] = _mm_madd_epi16(u[3], k__cospi_m18_p14);
2007   v[14] = _mm_madd_epi16(u[0], k__cospi_m02_p30);
2008   v[15] = _mm_madd_epi16(u[1], k__cospi_m02_p30);
2009
2010   u[0] = _mm_add_epi32(v[0], k__DCT_CONST_ROUNDING);
2011   u[1] = _mm_add_epi32(v[1], k__DCT_CONST_ROUNDING);
2012   u[2] = _mm_add_epi32(v[2], k__DCT_CONST_ROUNDING);
2013   u[3] = _mm_add_epi32(v[3], k__DCT_CONST_ROUNDING);
2014   u[4] = _mm_add_epi32(v[4], k__DCT_CONST_ROUNDING);
2015   u[5] = _mm_add_epi32(v[5], k__DCT_CONST_ROUNDING);
2016   u[6] = _mm_add_epi32(v[6], k__DCT_CONST_ROUNDING);
2017   u[7] = _mm_add_epi32(v[7], k__DCT_CONST_ROUNDING);
2018   u[8] = _mm_add_epi32(v[8], k__DCT_CONST_ROUNDING);
2019   u[9] = _mm_add_epi32(v[9], k__DCT_CONST_ROUNDING);
2020   u[10] = _mm_add_epi32(v[10], k__DCT_CONST_ROUNDING);
2021   u[11] = _mm_add_epi32(v[11], k__DCT_CONST_ROUNDING);
2022   u[12] = _mm_add_epi32(v[12], k__DCT_CONST_ROUNDING);
2023   u[13] = _mm_add_epi32(v[13], k__DCT_CONST_ROUNDING);
2024   u[14] = _mm_add_epi32(v[14], k__DCT_CONST_ROUNDING);
2025   u[15] = _mm_add_epi32(v[15], k__DCT_CONST_ROUNDING);
2026
2027   v[0] = _mm_srai_epi32(u[0], DCT_CONST_BITS);
2028   v[1] = _mm_srai_epi32(u[1], DCT_CONST_BITS);
2029   v[2] = _mm_srai_epi32(u[2], DCT_CONST_BITS);
2030   v[3] = _mm_srai_epi32(u[3], DCT_CONST_BITS);
2031   v[4] = _mm_srai_epi32(u[4], DCT_CONST_BITS);
2032   v[5] = _mm_srai_epi32(u[5], DCT_CONST_BITS);
2033   v[6] = _mm_srai_epi32(u[6], DCT_CONST_BITS);
2034   v[7] = _mm_srai_epi32(u[7], DCT_CONST_BITS);
2035   v[8] = _mm_srai_epi32(u[8], DCT_CONST_BITS);
2036   v[9] = _mm_srai_epi32(u[9], DCT_CONST_BITS);
2037   v[10] = _mm_srai_epi32(u[10], DCT_CONST_BITS);
2038   v[11] = _mm_srai_epi32(u[11], DCT_CONST_BITS);
2039   v[12] = _mm_srai_epi32(u[12], DCT_CONST_BITS);
2040   v[13] = _mm_srai_epi32(u[13], DCT_CONST_BITS);
2041   v[14] = _mm_srai_epi32(u[14], DCT_CONST_BITS);
2042   v[15] = _mm_srai_epi32(u[15], DCT_CONST_BITS);
2043
2044   in[1]  = _mm_packs_epi32(v[0], v[1]);
2045   in[9]  = _mm_packs_epi32(v[2], v[3]);
2046   in[5]  = _mm_packs_epi32(v[4], v[5]);
2047   in[13] = _mm_packs_epi32(v[6], v[7]);
2048   in[3]  = _mm_packs_epi32(v[8], v[9]);
2049   in[11] = _mm_packs_epi32(v[10], v[11]);
2050   in[7]  = _mm_packs_epi32(v[12], v[13]);
2051   in[15] = _mm_packs_epi32(v[14], v[15]);
2052 }
2053
2054 void fadst16_1d_8col(__m128i *in) {
2055   // perform 16x16 1-D ADST for 8 columns
2056   __m128i s[16], x[16], u[32], v[32];
2057   const __m128i k__cospi_p01_p31 = pair_set_epi16(cospi_1_64, cospi_31_64);
2058   const __m128i k__cospi_p31_m01 = pair_set_epi16(cospi_31_64, -cospi_1_64);
2059   const __m128i k__cospi_p05_p27 = pair_set_epi16(cospi_5_64, cospi_27_64);
2060   const __m128i k__cospi_p27_m05 = pair_set_epi16(cospi_27_64, -cospi_5_64);
2061   const __m128i k__cospi_p09_p23 = pair_set_epi16(cospi_9_64, cospi_23_64);
2062   const __m128i k__cospi_p23_m09 = pair_set_epi16(cospi_23_64, -cospi_9_64);
2063   const __m128i k__cospi_p13_p19 = pair_set_epi16(cospi_13_64, cospi_19_64);
2064   const __m128i k__cospi_p19_m13 = pair_set_epi16(cospi_19_64, -cospi_13_64);
2065   const __m128i k__cospi_p17_p15 = pair_set_epi16(cospi_17_64, cospi_15_64);
2066   const __m128i k__cospi_p15_m17 = pair_set_epi16(cospi_15_64, -cospi_17_64);
2067   const __m128i k__cospi_p21_p11 = pair_set_epi16(cospi_21_64, cospi_11_64);
2068   const __m128i k__cospi_p11_m21 = pair_set_epi16(cospi_11_64, -cospi_21_64);
2069   const __m128i k__cospi_p25_p07 = pair_set_epi16(cospi_25_64, cospi_7_64);
2070   const __m128i k__cospi_p07_m25 = pair_set_epi16(cospi_7_64, -cospi_25_64);
2071   const __m128i k__cospi_p29_p03 = pair_set_epi16(cospi_29_64, cospi_3_64);
2072   const __m128i k__cospi_p03_m29 = pair_set_epi16(cospi_3_64, -cospi_29_64);
2073   const __m128i k__cospi_p04_p28 = pair_set_epi16(cospi_4_64, cospi_28_64);
2074   const __m128i k__cospi_p28_m04 = pair_set_epi16(cospi_28_64, -cospi_4_64);
2075   const __m128i k__cospi_p20_p12 = pair_set_epi16(cospi_20_64, cospi_12_64);
2076   const __m128i k__cospi_p12_m20 = pair_set_epi16(cospi_12_64, -cospi_20_64);
2077   const __m128i k__cospi_m28_p04 = pair_set_epi16(-cospi_28_64, cospi_4_64);
2078   const __m128i k__cospi_m12_p20 = pair_set_epi16(-cospi_12_64, cospi_20_64);
2079   const __m128i k__cospi_p08_p24 = pair_set_epi16(cospi_8_64, cospi_24_64);
2080   const __m128i k__cospi_p24_m08 = pair_set_epi16(cospi_24_64, -cospi_8_64);
2081   const __m128i k__cospi_m24_p08 = pair_set_epi16(-cospi_24_64, cospi_8_64);
2082   const __m128i k__cospi_m16_m16 = _mm_set1_epi16(-cospi_16_64);
2083   const __m128i k__cospi_p16_p16 = _mm_set1_epi16(cospi_16_64);
2084   const __m128i k__cospi_p16_m16 = pair_set_epi16(cospi_16_64, -cospi_16_64);
2085   const __m128i k__cospi_m16_p16 = pair_set_epi16(-cospi_16_64, cospi_16_64);
2086   const __m128i k__DCT_CONST_ROUNDING = _mm_set1_epi32(DCT_CONST_ROUNDING);
2087   const __m128i kZero = _mm_set1_epi16(0);
2088
2089   u[0] = _mm_unpacklo_epi16(in[15], in[0]);
2090   u[1] = _mm_unpackhi_epi16(in[15], in[0]);
2091   u[2] = _mm_unpacklo_epi16(in[13], in[2]);
2092   u[3] = _mm_unpackhi_epi16(in[13], in[2]);
2093   u[4] = _mm_unpacklo_epi16(in[11], in[4]);
2094   u[5] = _mm_unpackhi_epi16(in[11], in[4]);
2095   u[6] = _mm_unpacklo_epi16(in[9], in[6]);
2096   u[7] = _mm_unpackhi_epi16(in[9], in[6]);
2097   u[8] = _mm_unpacklo_epi16(in[7], in[8]);
2098   u[9] = _mm_unpackhi_epi16(in[7], in[8]);
2099   u[10] = _mm_unpacklo_epi16(in[5], in[10]);
2100   u[11] = _mm_unpackhi_epi16(in[5], in[10]);
2101   u[12] = _mm_unpacklo_epi16(in[3], in[12]);
2102   u[13] = _mm_unpackhi_epi16(in[3], in[12]);
2103   u[14] = _mm_unpacklo_epi16(in[1], in[14]);
2104   u[15] = _mm_unpackhi_epi16(in[1], in[14]);
2105
2106   v[0] = _mm_madd_epi16(u[0], k__cospi_p01_p31);
2107   v[1] = _mm_madd_epi16(u[1], k__cospi_p01_p31);
2108   v[2] = _mm_madd_epi16(u[0], k__cospi_p31_m01);
2109   v[3] = _mm_madd_epi16(u[1], k__cospi_p31_m01);
2110   v[4] = _mm_madd_epi16(u[2], k__cospi_p05_p27);
2111   v[5] = _mm_madd_epi16(u[3], k__cospi_p05_p27);
2112   v[6] = _mm_madd_epi16(u[2], k__cospi_p27_m05);
2113   v[7] = _mm_madd_epi16(u[3], k__cospi_p27_m05);
2114   v[8] = _mm_madd_epi16(u[4], k__cospi_p09_p23);
2115   v[9] = _mm_madd_epi16(u[5], k__cospi_p09_p23);
2116   v[10] = _mm_madd_epi16(u[4], k__cospi_p23_m09);
2117   v[11] = _mm_madd_epi16(u[5], k__cospi_p23_m09);
2118   v[12] = _mm_madd_epi16(u[6], k__cospi_p13_p19);
2119   v[13] = _mm_madd_epi16(u[7], k__cospi_p13_p19);
2120   v[14] = _mm_madd_epi16(u[6], k__cospi_p19_m13);
2121   v[15] = _mm_madd_epi16(u[7], k__cospi_p19_m13);
2122   v[16] = _mm_madd_epi16(u[8], k__cospi_p17_p15);
2123   v[17] = _mm_madd_epi16(u[9], k__cospi_p17_p15);
2124   v[18] = _mm_madd_epi16(u[8], k__cospi_p15_m17);
2125   v[19] = _mm_madd_epi16(u[9], k__cospi_p15_m17);
2126   v[20] = _mm_madd_epi16(u[10], k__cospi_p21_p11);
2127   v[21] = _mm_madd_epi16(u[11], k__cospi_p21_p11);
2128   v[22] = _mm_madd_epi16(u[10], k__cospi_p11_m21);
2129   v[23] = _mm_madd_epi16(u[11], k__cospi_p11_m21);
2130   v[24] = _mm_madd_epi16(u[12], k__cospi_p25_p07);
2131   v[25] = _mm_madd_epi16(u[13], k__cospi_p25_p07);
2132   v[26] = _mm_madd_epi16(u[12], k__cospi_p07_m25);
2133   v[27] = _mm_madd_epi16(u[13], k__cospi_p07_m25);
2134   v[28] = _mm_madd_epi16(u[14], k__cospi_p29_p03);
2135   v[29] = _mm_madd_epi16(u[15], k__cospi_p29_p03);
2136   v[30] = _mm_madd_epi16(u[14], k__cospi_p03_m29);
2137   v[31] = _mm_madd_epi16(u[15], k__cospi_p03_m29);
2138
2139   u[0] = _mm_add_epi32(v[0], v[16]);
2140   u[1] = _mm_add_epi32(v[1], v[17]);
2141   u[2] = _mm_add_epi32(v[2], v[18]);
2142   u[3] = _mm_add_epi32(v[3], v[19]);
2143   u[4] = _mm_add_epi32(v[4], v[20]);
2144   u[5] = _mm_add_epi32(v[5], v[21]);
2145   u[6] = _mm_add_epi32(v[6], v[22]);
2146   u[7] = _mm_add_epi32(v[7], v[23]);
2147   u[8] = _mm_add_epi32(v[8], v[24]);
2148   u[9] = _mm_add_epi32(v[9], v[25]);
2149   u[10] = _mm_add_epi32(v[10], v[26]);
2150   u[11] = _mm_add_epi32(v[11], v[27]);
2151   u[12] = _mm_add_epi32(v[12], v[28]);
2152   u[13] = _mm_add_epi32(v[13], v[29]);
2153   u[14] = _mm_add_epi32(v[14], v[30]);
2154   u[15] = _mm_add_epi32(v[15], v[31]);
2155   u[16] = _mm_sub_epi32(v[0], v[16]);
2156   u[17] = _mm_sub_epi32(v[1], v[17]);
2157   u[18] = _mm_sub_epi32(v[2], v[18]);
2158   u[19] = _mm_sub_epi32(v[3], v[19]);
2159   u[20] = _mm_sub_epi32(v[4], v[20]);
2160   u[21] = _mm_sub_epi32(v[5], v[21]);
2161   u[22] = _mm_sub_epi32(v[6], v[22]);
2162   u[23] = _mm_sub_epi32(v[7], v[23]);
2163   u[24] = _mm_sub_epi32(v[8], v[24]);
2164   u[25] = _mm_sub_epi32(v[9], v[25]);
2165   u[26] = _mm_sub_epi32(v[10], v[26]);
2166   u[27] = _mm_sub_epi32(v[11], v[27]);
2167   u[28] = _mm_sub_epi32(v[12], v[28]);
2168   u[29] = _mm_sub_epi32(v[13], v[29]);
2169   u[30] = _mm_sub_epi32(v[14], v[30]);
2170   u[31] = _mm_sub_epi32(v[15], v[31]);
2171
2172   v[0] = _mm_add_epi32(u[0], k__DCT_CONST_ROUNDING);
2173   v[1] = _mm_add_epi32(u[1], k__DCT_CONST_ROUNDING);
2174   v[2] = _mm_add_epi32(u[2], k__DCT_CONST_ROUNDING);
2175   v[3] = _mm_add_epi32(u[3], k__DCT_CONST_ROUNDING);
2176   v[4] = _mm_add_epi32(u[4], k__DCT_CONST_ROUNDING);
2177   v[5] = _mm_add_epi32(u[5], k__DCT_CONST_ROUNDING);
2178   v[6] = _mm_add_epi32(u[6], k__DCT_CONST_ROUNDING);
2179   v[7] = _mm_add_epi32(u[7], k__DCT_CONST_ROUNDING);
2180   v[8] = _mm_add_epi32(u[8], k__DCT_CONST_ROUNDING);
2181   v[9] = _mm_add_epi32(u[9], k__DCT_CONST_ROUNDING);
2182   v[10] = _mm_add_epi32(u[10], k__DCT_CONST_ROUNDING);
2183   v[11] = _mm_add_epi32(u[11], k__DCT_CONST_ROUNDING);
2184   v[12] = _mm_add_epi32(u[12], k__DCT_CONST_ROUNDING);
2185   v[13] = _mm_add_epi32(u[13], k__DCT_CONST_ROUNDING);
2186   v[14] = _mm_add_epi32(u[14], k__DCT_CONST_ROUNDING);
2187   v[15] = _mm_add_epi32(u[15], k__DCT_CONST_ROUNDING);
2188   v[16] = _mm_add_epi32(u[16], k__DCT_CONST_ROUNDING);
2189   v[17] = _mm_add_epi32(u[17], k__DCT_CONST_ROUNDING);
2190   v[18] = _mm_add_epi32(u[18], k__DCT_CONST_ROUNDING);
2191   v[19] = _mm_add_epi32(u[19], k__DCT_CONST_ROUNDING);
2192   v[20] = _mm_add_epi32(u[20], k__DCT_CONST_ROUNDING);
2193   v[21] = _mm_add_epi32(u[21], k__DCT_CONST_ROUNDING);
2194   v[22] = _mm_add_epi32(u[22], k__DCT_CONST_ROUNDING);
2195   v[23] = _mm_add_epi32(u[23], k__DCT_CONST_ROUNDING);
2196   v[24] = _mm_add_epi32(u[24], k__DCT_CONST_ROUNDING);
2197   v[25] = _mm_add_epi32(u[25], k__DCT_CONST_ROUNDING);
2198   v[26] = _mm_add_epi32(u[26], k__DCT_CONST_ROUNDING);
2199   v[27] = _mm_add_epi32(u[27], k__DCT_CONST_ROUNDING);
2200   v[28] = _mm_add_epi32(u[28], k__DCT_CONST_ROUNDING);
2201   v[29] = _mm_add_epi32(u[29], k__DCT_CONST_ROUNDING);
2202   v[30] = _mm_add_epi32(u[30], k__DCT_CONST_ROUNDING);
2203   v[31] = _mm_add_epi32(u[31], k__DCT_CONST_ROUNDING);
2204
2205   u[0] = _mm_srai_epi32(v[0], DCT_CONST_BITS);
2206   u[1] = _mm_srai_epi32(v[1], DCT_CONST_BITS);
2207   u[2] = _mm_srai_epi32(v[2], DCT_CONST_BITS);
2208   u[3] = _mm_srai_epi32(v[3], DCT_CONST_BITS);
2209   u[4] = _mm_srai_epi32(v[4], DCT_CONST_BITS);
2210   u[5] = _mm_srai_epi32(v[5], DCT_CONST_BITS);
2211   u[6] = _mm_srai_epi32(v[6], DCT_CONST_BITS);
2212   u[7] = _mm_srai_epi32(v[7], DCT_CONST_BITS);
2213   u[8] = _mm_srai_epi32(v[8], DCT_CONST_BITS);
2214   u[9] = _mm_srai_epi32(v[9], DCT_CONST_BITS);
2215   u[10] = _mm_srai_epi32(v[10], DCT_CONST_BITS);
2216   u[11] = _mm_srai_epi32(v[11], DCT_CONST_BITS);
2217   u[12] = _mm_srai_epi32(v[12], DCT_CONST_BITS);
2218   u[13] = _mm_srai_epi32(v[13], DCT_CONST_BITS);
2219   u[14] = _mm_srai_epi32(v[14], DCT_CONST_BITS);
2220   u[15] = _mm_srai_epi32(v[15], DCT_CONST_BITS);
2221   u[16] = _mm_srai_epi32(v[16], DCT_CONST_BITS);
2222   u[17] = _mm_srai_epi32(v[17], DCT_CONST_BITS);
2223   u[18] = _mm_srai_epi32(v[18], DCT_CONST_BITS);
2224   u[19] = _mm_srai_epi32(v[19], DCT_CONST_BITS);
2225   u[20] = _mm_srai_epi32(v[20], DCT_CONST_BITS);
2226   u[21] = _mm_srai_epi32(v[21], DCT_CONST_BITS);
2227   u[22] = _mm_srai_epi32(v[22], DCT_CONST_BITS);
2228   u[23] = _mm_srai_epi32(v[23], DCT_CONST_BITS);
2229   u[24] = _mm_srai_epi32(v[24], DCT_CONST_BITS);
2230   u[25] = _mm_srai_epi32(v[25], DCT_CONST_BITS);
2231   u[26] = _mm_srai_epi32(v[26], DCT_CONST_BITS);
2232   u[27] = _mm_srai_epi32(v[27], DCT_CONST_BITS);
2233   u[28] = _mm_srai_epi32(v[28], DCT_CONST_BITS);
2234   u[29] = _mm_srai_epi32(v[29], DCT_CONST_BITS);
2235   u[30] = _mm_srai_epi32(v[30], DCT_CONST_BITS);
2236   u[31] = _mm_srai_epi32(v[31], DCT_CONST_BITS);
2237
2238   s[0] = _mm_packs_epi32(u[0], u[1]);
2239   s[1] = _mm_packs_epi32(u[2], u[3]);
2240   s[2] = _mm_packs_epi32(u[4], u[5]);
2241   s[3] = _mm_packs_epi32(u[6], u[7]);
2242   s[4] = _mm_packs_epi32(u[8], u[9]);
2243   s[5] = _mm_packs_epi32(u[10], u[11]);
2244   s[6] = _mm_packs_epi32(u[12], u[13]);
2245   s[7] = _mm_packs_epi32(u[14], u[15]);
2246   s[8] = _mm_packs_epi32(u[16], u[17]);
2247   s[9] = _mm_packs_epi32(u[18], u[19]);
2248   s[10] = _mm_packs_epi32(u[20], u[21]);
2249   s[11] = _mm_packs_epi32(u[22], u[23]);
2250   s[12] = _mm_packs_epi32(u[24], u[25]);
2251   s[13] = _mm_packs_epi32(u[26], u[27]);
2252   s[14] = _mm_packs_epi32(u[28], u[29]);
2253   s[15] = _mm_packs_epi32(u[30], u[31]);
2254
2255   // stage 2
2256   u[0] = _mm_unpacklo_epi16(s[8], s[9]);
2257   u[1] = _mm_unpackhi_epi16(s[8], s[9]);
2258   u[2] = _mm_unpacklo_epi16(s[10], s[11]);
2259   u[3] = _mm_unpackhi_epi16(s[10], s[11]);
2260   u[4] = _mm_unpacklo_epi16(s[12], s[13]);
2261   u[5] = _mm_unpackhi_epi16(s[12], s[13]);
2262   u[6] = _mm_unpacklo_epi16(s[14], s[15]);
2263   u[7] = _mm_unpackhi_epi16(s[14], s[15]);
2264
2265   v[0] = _mm_madd_epi16(u[0], k__cospi_p04_p28);
2266   v[1] = _mm_madd_epi16(u[1], k__cospi_p04_p28);
2267   v[2] = _mm_madd_epi16(u[0], k__cospi_p28_m04);
2268   v[3] = _mm_madd_epi16(u[1], k__cospi_p28_m04);
2269   v[4] = _mm_madd_epi16(u[2], k__cospi_p20_p12);
2270   v[5] = _mm_madd_epi16(u[3], k__cospi_p20_p12);
2271   v[6] = _mm_madd_epi16(u[2], k__cospi_p12_m20);
2272   v[7] = _mm_madd_epi16(u[3], k__cospi_p12_m20);
2273   v[8] = _mm_madd_epi16(u[4], k__cospi_m28_p04);
2274   v[9] = _mm_madd_epi16(u[5], k__cospi_m28_p04);
2275   v[10] = _mm_madd_epi16(u[4], k__cospi_p04_p28);
2276   v[11] = _mm_madd_epi16(u[5], k__cospi_p04_p28);
2277   v[12] = _mm_madd_epi16(u[6], k__cospi_m12_p20);
2278   v[13] = _mm_madd_epi16(u[7], k__cospi_m12_p20);
2279   v[14] = _mm_madd_epi16(u[6], k__cospi_p20_p12);
2280   v[15] = _mm_madd_epi16(u[7], k__cospi_p20_p12);
2281
2282   u[0] = _mm_add_epi32(v[0], v[8]);
2283   u[1] = _mm_add_epi32(v[1], v[9]);
2284   u[2] = _mm_add_epi32(v[2], v[10]);
2285   u[3] = _mm_add_epi32(v[3], v[11]);
2286   u[4] = _mm_add_epi32(v[4], v[12]);
2287   u[5] = _mm_add_epi32(v[5], v[13]);
2288   u[6] = _mm_add_epi32(v[6], v[14]);
2289   u[7] = _mm_add_epi32(v[7], v[15]);
2290   u[8] = _mm_sub_epi32(v[0], v[8]);
2291   u[9] = _mm_sub_epi32(v[1], v[9]);
2292   u[10] = _mm_sub_epi32(v[2], v[10]);
2293   u[11] = _mm_sub_epi32(v[3], v[11]);
2294   u[12] = _mm_sub_epi32(v[4], v[12]);
2295   u[13] = _mm_sub_epi32(v[5], v[13]);
2296   u[14] = _mm_sub_epi32(v[6], v[14]);
2297   u[15] = _mm_sub_epi32(v[7], v[15]);
2298
2299   v[0] = _mm_add_epi32(u[0], k__DCT_CONST_ROUNDING);
2300   v[1] = _mm_add_epi32(u[1], k__DCT_CONST_ROUNDING);
2301   v[2] = _mm_add_epi32(u[2], k__DCT_CONST_ROUNDING);
2302   v[3] = _mm_add_epi32(u[3], k__DCT_CONST_ROUNDING);
2303   v[4] = _mm_add_epi32(u[4], k__DCT_CONST_ROUNDING);
2304   v[5] = _mm_add_epi32(u[5], k__DCT_CONST_ROUNDING);
2305   v[6] = _mm_add_epi32(u[6], k__DCT_CONST_ROUNDING);
2306   v[7] = _mm_add_epi32(u[7], k__DCT_CONST_ROUNDING);
2307   v[8] = _mm_add_epi32(u[8], k__DCT_CONST_ROUNDING);
2308   v[9] = _mm_add_epi32(u[9], k__DCT_CONST_ROUNDING);
2309   v[10] = _mm_add_epi32(u[10], k__DCT_CONST_ROUNDING);
2310   v[11] = _mm_add_epi32(u[11], k__DCT_CONST_ROUNDING);
2311   v[12] = _mm_add_epi32(u[12], k__DCT_CONST_ROUNDING);
2312   v[13] = _mm_add_epi32(u[13], k__DCT_CONST_ROUNDING);
2313   v[14] = _mm_add_epi32(u[14], k__DCT_CONST_ROUNDING);
2314   v[15] = _mm_add_epi32(u[15], k__DCT_CONST_ROUNDING);
2315
2316   u[0] = _mm_srai_epi32(v[0], DCT_CONST_BITS);
2317   u[1] = _mm_srai_epi32(v[1], DCT_CONST_BITS);
2318   u[2] = _mm_srai_epi32(v[2], DCT_CONST_BITS);
2319   u[3] = _mm_srai_epi32(v[3], DCT_CONST_BITS);
2320   u[4] = _mm_srai_epi32(v[4], DCT_CONST_BITS);
2321   u[5] = _mm_srai_epi32(v[5], DCT_CONST_BITS);
2322   u[6] = _mm_srai_epi32(v[6], DCT_CONST_BITS);
2323   u[7] = _mm_srai_epi32(v[7], DCT_CONST_BITS);
2324   u[8] = _mm_srai_epi32(v[8], DCT_CONST_BITS);
2325   u[9] = _mm_srai_epi32(v[9], DCT_CONST_BITS);
2326   u[10] = _mm_srai_epi32(v[10], DCT_CONST_BITS);
2327   u[11] = _mm_srai_epi32(v[11], DCT_CONST_BITS);
2328   u[12] = _mm_srai_epi32(v[12], DCT_CONST_BITS);
2329   u[13] = _mm_srai_epi32(v[13], DCT_CONST_BITS);
2330   u[14] = _mm_srai_epi32(v[14], DCT_CONST_BITS);
2331   u[15] = _mm_srai_epi32(v[15], DCT_CONST_BITS);
2332
2333   x[0] = _mm_add_epi16(s[0], s[4]);
2334   x[1] = _mm_add_epi16(s[1], s[5]);
2335   x[2] = _mm_add_epi16(s[2], s[6]);
2336   x[3] = _mm_add_epi16(s[3], s[7]);
2337   x[4] = _mm_sub_epi16(s[0], s[4]);
2338   x[5] = _mm_sub_epi16(s[1], s[5]);
2339   x[6] = _mm_sub_epi16(s[2], s[6]);
2340   x[7] = _mm_sub_epi16(s[3], s[7]);
2341   x[8] = _mm_packs_epi32(u[0], u[1]);
2342   x[9] = _mm_packs_epi32(u[2], u[3]);
2343   x[10] = _mm_packs_epi32(u[4], u[5]);
2344   x[11] = _mm_packs_epi32(u[6], u[7]);
2345   x[12] = _mm_packs_epi32(u[8], u[9]);
2346   x[13] = _mm_packs_epi32(u[10], u[11]);
2347   x[14] = _mm_packs_epi32(u[12], u[13]);
2348   x[15] = _mm_packs_epi32(u[14], u[15]);
2349
2350   // stage 3
2351   u[0] = _mm_unpacklo_epi16(x[4], x[5]);
2352   u[1] = _mm_unpackhi_epi16(x[4], x[5]);
2353   u[2] = _mm_unpacklo_epi16(x[6], x[7]);
2354   u[3] = _mm_unpackhi_epi16(x[6], x[7]);
2355   u[4] = _mm_unpacklo_epi16(x[12], x[13]);
2356   u[5] = _mm_unpackhi_epi16(x[12], x[13]);
2357   u[6] = _mm_unpacklo_epi16(x[14], x[15]);
2358   u[7] = _mm_unpackhi_epi16(x[14], x[15]);
2359
2360   v[0] = _mm_madd_epi16(u[0], k__cospi_p08_p24);
2361   v[1] = _mm_madd_epi16(u[1], k__cospi_p08_p24);
2362   v[2] = _mm_madd_epi16(u[0], k__cospi_p24_m08);
2363   v[3] = _mm_madd_epi16(u[1], k__cospi_p24_m08);
2364   v[4] = _mm_madd_epi16(u[2], k__cospi_m24_p08);
2365   v[5] = _mm_madd_epi16(u[3], k__cospi_m24_p08);
2366   v[6] = _mm_madd_epi16(u[2], k__cospi_p08_p24);
2367   v[7] = _mm_madd_epi16(u[3], k__cospi_p08_p24);
2368   v[8] = _mm_madd_epi16(u[4], k__cospi_p08_p24);
2369   v[9] = _mm_madd_epi16(u[5], k__cospi_p08_p24);
2370   v[10] = _mm_madd_epi16(u[4], k__cospi_p24_m08);
2371   v[11] = _mm_madd_epi16(u[5], k__cospi_p24_m08);
2372   v[12] = _mm_madd_epi16(u[6], k__cospi_m24_p08);
2373   v[13] = _mm_madd_epi16(u[7], k__cospi_m24_p08);
2374   v[14] = _mm_madd_epi16(u[6], k__cospi_p08_p24);
2375   v[15] = _mm_madd_epi16(u[7], k__cospi_p08_p24);
2376
2377   u[0] = _mm_add_epi32(v[0], v[4]);
2378   u[1] = _mm_add_epi32(v[1], v[5]);
2379   u[2] = _mm_add_epi32(v[2], v[6]);
2380   u[3] = _mm_add_epi32(v[3], v[7]);
2381   u[4] = _mm_sub_epi32(v[0], v[4]);
2382   u[5] = _mm_sub_epi32(v[1], v[5]);
2383   u[6] = _mm_sub_epi32(v[2], v[6]);
2384   u[7] = _mm_sub_epi32(v[3], v[7]);
2385   u[8] = _mm_add_epi32(v[8], v[12]);
2386   u[9] = _mm_add_epi32(v[9], v[13]);
2387   u[10] = _mm_add_epi32(v[10], v[14]);
2388   u[11] = _mm_add_epi32(v[11], v[15]);
2389   u[12] = _mm_sub_epi32(v[8], v[12]);
2390   u[13] = _mm_sub_epi32(v[9], v[13]);
2391   u[14] = _mm_sub_epi32(v[10], v[14]);
2392   u[15] = _mm_sub_epi32(v[11], v[15]);
2393
2394   u[0] = _mm_add_epi32(u[0], k__DCT_CONST_ROUNDING);
2395   u[1] = _mm_add_epi32(u[1], k__DCT_CONST_ROUNDING);
2396   u[2] = _mm_add_epi32(u[2], k__DCT_CONST_ROUNDING);
2397   u[3] = _mm_add_epi32(u[3], k__DCT_CONST_ROUNDING);
2398   u[4] = _mm_add_epi32(u[4], k__DCT_CONST_ROUNDING);
2399   u[5] = _mm_add_epi32(u[5], k__DCT_CONST_ROUNDING);
2400   u[6] = _mm_add_epi32(u[6], k__DCT_CONST_ROUNDING);
2401   u[7] = _mm_add_epi32(u[7], k__DCT_CONST_ROUNDING);
2402   u[8] = _mm_add_epi32(u[8], k__DCT_CONST_ROUNDING);
2403   u[9] = _mm_add_epi32(u[9], k__DCT_CONST_ROUNDING);
2404   u[10] = _mm_add_epi32(u[10], k__DCT_CONST_ROUNDING);
2405   u[11] = _mm_add_epi32(u[11], k__DCT_CONST_ROUNDING);
2406   u[12] = _mm_add_epi32(u[12], k__DCT_CONST_ROUNDING);
2407   u[13] = _mm_add_epi32(u[13], k__DCT_CONST_ROUNDING);
2408   u[14] = _mm_add_epi32(u[14], k__DCT_CONST_ROUNDING);
2409   u[15] = _mm_add_epi32(u[15], k__DCT_CONST_ROUNDING);
2410
2411   v[0] = _mm_srai_epi32(u[0], DCT_CONST_BITS);
2412   v[1] = _mm_srai_epi32(u[1], DCT_CONST_BITS);
2413   v[2] = _mm_srai_epi32(u[2], DCT_CONST_BITS);
2414   v[3] = _mm_srai_epi32(u[3], DCT_CONST_BITS);
2415   v[4] = _mm_srai_epi32(u[4], DCT_CONST_BITS);
2416   v[5] = _mm_srai_epi32(u[5], DCT_CONST_BITS);
2417   v[6] = _mm_srai_epi32(u[6], DCT_CONST_BITS);
2418   v[7] = _mm_srai_epi32(u[7], DCT_CONST_BITS);
2419   v[8] = _mm_srai_epi32(u[8], DCT_CONST_BITS);
2420   v[9] = _mm_srai_epi32(u[9], DCT_CONST_BITS);
2421   v[10] = _mm_srai_epi32(u[10], DCT_CONST_BITS);
2422   v[11] = _mm_srai_epi32(u[11], DCT_CONST_BITS);
2423   v[12] = _mm_srai_epi32(u[12], DCT_CONST_BITS);
2424   v[13] = _mm_srai_epi32(u[13], DCT_CONST_BITS);
2425   v[14] = _mm_srai_epi32(u[14], DCT_CONST_BITS);
2426   v[15] = _mm_srai_epi32(u[15], DCT_CONST_BITS);
2427
2428   s[0] = _mm_add_epi16(x[0], x[2]);
2429   s[1] = _mm_add_epi16(x[1], x[3]);
2430   s[2] = _mm_sub_epi16(x[0], x[2]);
2431   s[3] = _mm_sub_epi16(x[1], x[3]);
2432   s[4] = _mm_packs_epi32(v[0], v[1]);
2433   s[5] = _mm_packs_epi32(v[2], v[3]);
2434   s[6] = _mm_packs_epi32(v[4], v[5]);
2435   s[7] = _mm_packs_epi32(v[6], v[7]);
2436   s[8] = _mm_add_epi16(x[8], x[10]);
2437   s[9] = _mm_add_epi16(x[9], x[11]);
2438   s[10] = _mm_sub_epi16(x[8], x[10]);
2439   s[11] = _mm_sub_epi16(x[9], x[11]);
2440   s[12] = _mm_packs_epi32(v[8], v[9]);
2441   s[13] = _mm_packs_epi32(v[10], v[11]);
2442   s[14] = _mm_packs_epi32(v[12], v[13]);
2443   s[15] = _mm_packs_epi32(v[14], v[15]);
2444
2445   // stage 4
2446   u[0] = _mm_unpacklo_epi16(s[2], s[3]);
2447   u[1] = _mm_unpackhi_epi16(s[2], s[3]);
2448   u[2] = _mm_unpacklo_epi16(s[6], s[7]);
2449   u[3] = _mm_unpackhi_epi16(s[6], s[7]);
2450   u[4] = _mm_unpacklo_epi16(s[10], s[11]);
2451   u[5] = _mm_unpackhi_epi16(s[10], s[11]);
2452   u[6] = _mm_unpacklo_epi16(s[14], s[15]);
2453   u[7] = _mm_unpackhi_epi16(s[14], s[15]);
2454
2455   v[0] = _mm_madd_epi16(u[0], k__cospi_m16_m16);
2456   v[1] = _mm_madd_epi16(u[1], k__cospi_m16_m16);
2457   v[2] = _mm_madd_epi16(u[0], k__cospi_p16_m16);
2458   v[3] = _mm_madd_epi16(u[1], k__cospi_p16_m16);
2459   v[4] = _mm_madd_epi16(u[2], k__cospi_p16_p16);
2460   v[5] = _mm_madd_epi16(u[3], k__cospi_p16_p16);
2461   v[6] = _mm_madd_epi16(u[2], k__cospi_m16_p16);
2462   v[7] = _mm_madd_epi16(u[3], k__cospi_m16_p16);
2463   v[8] = _mm_madd_epi16(u[4], k__cospi_p16_p16);
2464   v[9] = _mm_madd_epi16(u[5], k__cospi_p16_p16);
2465   v[10] = _mm_madd_epi16(u[4], k__cospi_m16_p16);
2466   v[11] = _mm_madd_epi16(u[5], k__cospi_m16_p16);
2467   v[12] = _mm_madd_epi16(u[6], k__cospi_m16_m16);
2468   v[13] = _mm_madd_epi16(u[7], k__cospi_m16_m16);
2469   v[14] = _mm_madd_epi16(u[6], k__cospi_p16_m16);
2470   v[15] = _mm_madd_epi16(u[7], k__cospi_p16_m16);
2471
2472   u[0] = _mm_add_epi32(v[0], k__DCT_CONST_ROUNDING);
2473   u[1] = _mm_add_epi32(v[1], k__DCT_CONST_ROUNDING);
2474   u[2] = _mm_add_epi32(v[2], k__DCT_CONST_ROUNDING);
2475   u[3] = _mm_add_epi32(v[3], k__DCT_CONST_ROUNDING);
2476   u[4] = _mm_add_epi32(v[4], k__DCT_CONST_ROUNDING);
2477   u[5] = _mm_add_epi32(v[5], k__DCT_CONST_ROUNDING);
2478   u[6] = _mm_add_epi32(v[6], k__DCT_CONST_ROUNDING);
2479   u[7] = _mm_add_epi32(v[7], k__DCT_CONST_ROUNDING);
2480   u[8] = _mm_add_epi32(v[8], k__DCT_CONST_ROUNDING);
2481   u[9] = _mm_add_epi32(v[9], k__DCT_CONST_ROUNDING);
2482   u[10] = _mm_add_epi32(v[10], k__DCT_CONST_ROUNDING);
2483   u[11] = _mm_add_epi32(v[11], k__DCT_CONST_ROUNDING);
2484   u[12] = _mm_add_epi32(v[12], k__DCT_CONST_ROUNDING);
2485   u[13] = _mm_add_epi32(v[13], k__DCT_CONST_ROUNDING);
2486   u[14] = _mm_add_epi32(v[14], k__DCT_CONST_ROUNDING);
2487   u[15] = _mm_add_epi32(v[15], k__DCT_CONST_ROUNDING);
2488
2489   v[0] = _mm_srai_epi32(u[0], DCT_CONST_BITS);
2490   v[1] = _mm_srai_epi32(u[1], DCT_CONST_BITS);
2491   v[2] = _mm_srai_epi32(u[2], DCT_CONST_BITS);
2492   v[3] = _mm_srai_epi32(u[3], DCT_CONST_BITS);
2493   v[4] = _mm_srai_epi32(u[4], DCT_CONST_BITS);
2494   v[5] = _mm_srai_epi32(u[5], DCT_CONST_BITS);
2495   v[6] = _mm_srai_epi32(u[6], DCT_CONST_BITS);
2496   v[7] = _mm_srai_epi32(u[7], DCT_CONST_BITS);
2497   v[8] = _mm_srai_epi32(u[8], DCT_CONST_BITS);
2498   v[9] = _mm_srai_epi32(u[9], DCT_CONST_BITS);
2499   v[10] = _mm_srai_epi32(u[10], DCT_CONST_BITS);
2500   v[11] = _mm_srai_epi32(u[11], DCT_CONST_BITS);
2501   v[12] = _mm_srai_epi32(u[12], DCT_CONST_BITS);
2502   v[13] = _mm_srai_epi32(u[13], DCT_CONST_BITS);
2503   v[14] = _mm_srai_epi32(u[14], DCT_CONST_BITS);
2504   v[15] = _mm_srai_epi32(u[15], DCT_CONST_BITS);
2505
2506   in[0] = s[0];
2507   in[1] = _mm_sub_epi16(kZero, s[8]);
2508   in[2] = s[12];
2509   in[3] = _mm_sub_epi16(kZero, s[4]);
2510   in[4] = _mm_packs_epi32(v[4], v[5]);
2511   in[5] = _mm_packs_epi32(v[12], v[13]);
2512   in[6] = _mm_packs_epi32(v[8], v[9]);
2513   in[7] = _mm_packs_epi32(v[0], v[1]);
2514   in[8] = _mm_packs_epi32(v[2], v[3]);
2515   in[9] = _mm_packs_epi32(v[10], v[11]);
2516   in[10] = _mm_packs_epi32(v[14], v[15]);
2517   in[11] = _mm_packs_epi32(v[6], v[7]);
2518   in[12] = s[5];
2519   in[13] = _mm_sub_epi16(kZero, s[13]);
2520   in[14] = s[9];
2521   in[15] = _mm_sub_epi16(kZero, s[1]);
2522 }
2523
2524 void fdct16_1d_sse2(__m128i *in0, __m128i *in1) {
2525   fdct16_1d_8col(in0);
2526   fdct16_1d_8col(in1);
2527   array_transpose_16x16(in0, in1);
2528 }
2529
2530 void fadst16_1d_sse2(__m128i *in0, __m128i *in1) {
2531   fadst16_1d_8col(in0);
2532   fadst16_1d_8col(in1);
2533   array_transpose_16x16(in0, in1);
2534 }
2535
2536 void vp9_short_fht16x16_sse2(const int16_t *input, int16_t *output,
2537                              int stride, int tx_type) {
2538   __m128i in0[16], in1[16];
2539   load_buffer_16x16(input, in0, in1, stride);
2540   switch (tx_type) {
2541     case 0:  // DCT_DCT
2542       fdct16_1d_sse2(in0, in1);
2543       right_shift_16x16(in0, in1);
2544       fdct16_1d_sse2(in0, in1);
2545       break;
2546     case 1:  // ADST_DCT
2547       fadst16_1d_sse2(in0, in1);
2548       right_shift_16x16(in0, in1);
2549       fdct16_1d_sse2(in0, in1);
2550       break;
2551     case 2:  // DCT_ADST
2552       fdct16_1d_sse2(in0, in1);
2553       right_shift_16x16(in0, in1);
2554       fadst16_1d_sse2(in0, in1);
2555       break;
2556     case 3:  // ADST_ADST
2557       fadst16_1d_sse2(in0, in1);
2558       right_shift_16x16(in0, in1);
2559       fadst16_1d_sse2(in0, in1);
2560       break;
2561     default:
2562       assert(0);
2563       break;
2564   }
2565   write_buffer_16x16(output, in0, in1, 16);
2566 }
2567
2568 #define FDCT32x32_2D vp9_fdct32x32_rd_sse2
2569 #define FDCT32x32_HIGH_PRECISION 0
2570 #include "vp9/encoder/x86/vp9_dct32x32_sse2.c"
2571 #undef  FDCT32x32_2D
2572 #undef  FDCT32x32_HIGH_PRECISION
2573
2574 #define FDCT32x32_2D vp9_fdct32x32_sse2
2575 #define FDCT32x32_HIGH_PRECISION 1
2576 #include "vp9/encoder/x86/vp9_dct32x32_sse2.c" // NOLINT
2577 #undef  FDCT32x32_2D
2578 #undef  FDCT32x32_HIGH_PRECISION