granicus.if.org Git - libvpx/blob - vpx_dsp/x86/vpx_subpixel_8t_intrin_avx2.c

   1 /*
   2  *  Copyright (c) 2010 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 <immintrin.h>
  12
  13 #include "./vpx_dsp_rtcd.h"
  14 #include "vpx_dsp/x86/convolve.h"
  15 #include "vpx_ports/mem.h"
  16
  17 // filters for 16_h8 and 16_v8
  18 DECLARE_ALIGNED(32, static const uint8_t, filt1_global_avx2[32]) = {
  19   0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8,
  20   0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8
  21 };
  22
  23 DECLARE_ALIGNED(32, static const uint8_t, filt2_global_avx2[32]) = {
  24   2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10,
  25   2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10
  26 };
  27
  28 DECLARE_ALIGNED(32, static const uint8_t, filt3_global_avx2[32]) = {
  29   4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12,
  30   4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12
  31 };
  32
  33 DECLARE_ALIGNED(32, static const uint8_t, filt4_global_avx2[32]) = {
  34   6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14,
  35   6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14
  36 };
  37
  38 #if defined(__clang__)
  39 #if (__clang_major__ > 0 && __clang_major__ < 3) ||            \
  40     (__clang_major__ == 3 && __clang_minor__ <= 3) ||          \
  41     (defined(__APPLE__) && defined(__apple_build_version__) && \
  42      ((__clang_major__ == 4 && __clang_minor__ <= 2) ||        \
  43       (__clang_major__ == 5 && __clang_minor__ == 0)))
  44 #define MM256_BROADCASTSI128_SI256(x) \
  45   _mm_broadcastsi128_si256((__m128i const *)&(x))
  46 #else  // clang > 3.3, and not 5.0 on macosx.
  47 #define MM256_BROADCASTSI128_SI256(x) _mm256_broadcastsi128_si256(x)
  48 #endif  // clang <= 3.3
  49 #elif defined(__GNUC__)
  50 #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ <= 6)
  51 #define MM256_BROADCASTSI128_SI256(x) \
  52   _mm_broadcastsi128_si256((__m128i const *)&(x))
  53 #elif __GNUC__ == 4 && __GNUC_MINOR__ == 7
  54 #define MM256_BROADCASTSI128_SI256(x) _mm_broadcastsi128_si256(x)
  55 #else  // gcc > 4.7
  56 #define MM256_BROADCASTSI128_SI256(x) _mm256_broadcastsi128_si256(x)
  57 #endif  // gcc <= 4.6
  58 #else   // !(gcc || clang)
  59 #define MM256_BROADCASTSI128_SI256(x) _mm256_broadcastsi128_si256(x)
  60 #endif  // __clang__
  61
  62 static INLINE void vpx_filter_block1d16_h8_X_avx2(
  63     const uint8_t *src_ptr, ptrdiff_t src_pixels_per_line, uint8_t *output_ptr,
  64     ptrdiff_t output_pitch, uint32_t output_height, const int16_t *filter,
  65     const int avg) {
  66   __m128i filtersReg, outReg1, outReg2;
  67   __m256i addFilterReg64, filt1Reg, filt2Reg, filt3Reg, filt4Reg;
  68   __m256i firstFilters, secondFilters, thirdFilters, forthFilters;
  69   __m256i srcRegFilt32b1_1, srcRegFilt32b2_1, srcRegFilt32b2, srcRegFilt32b3;
  70   __m256i srcReg32b1, srcReg32b2, filtersReg32;
  71   unsigned int i;
  72   ptrdiff_t src_stride, dst_stride;
  73
  74   // create a register with 0,64,0,64,0,64,0,64,0,64,0,64,0,64,0,64
  75   addFilterReg64 = _mm256_set1_epi32((int)0x0400040u);
  76   filtersReg = _mm_loadu_si128((const __m128i *)filter);
  77   // converting the 16 bit (short) to 8 bit (byte) and have the same data
  78   // in both lanes of 128 bit register.
  79   filtersReg = _mm_packs_epi16(filtersReg, filtersReg);
  80   // have the same data in both lanes of a 256 bit register
  81   filtersReg32 = MM256_BROADCASTSI128_SI256(filtersReg);
  82
  83   // duplicate only the first 16 bits (first and second byte)
  84   // across 256 bit register
  85   firstFilters = _mm256_shuffle_epi8(filtersReg32, _mm256_set1_epi16(0x100u));
  86   // duplicate only the second 16 bits (third and forth byte)
  87   // across 256 bit register
  88   secondFilters = _mm256_shuffle_epi8(filtersReg32, _mm256_set1_epi16(0x302u));
  89   // duplicate only the third 16 bits (fifth and sixth byte)
  90   // across 256 bit register
  91   thirdFilters = _mm256_shuffle_epi8(filtersReg32, _mm256_set1_epi16(0x504u));
  92   // duplicate only the forth 16 bits (seventh and eighth byte)
  93   // across 256 bit register
  94   forthFilters = _mm256_shuffle_epi8(filtersReg32, _mm256_set1_epi16(0x706u));
  95
  96   filt1Reg = _mm256_load_si256((__m256i const *)filt1_global_avx2);
  97   filt2Reg = _mm256_load_si256((__m256i const *)filt2_global_avx2);
  98   filt3Reg = _mm256_load_si256((__m256i const *)filt3_global_avx2);
  99   filt4Reg = _mm256_load_si256((__m256i const *)filt4_global_avx2);
 100
 101   // multiple the size of the source and destination stride by two
 102   src_stride = src_pixels_per_line << 1;
 103   dst_stride = output_pitch << 1;
 104   for (i = output_height; i > 1; i -= 2) {
 105     // load the 2 strides of source
 106     srcReg32b1 =
 107         _mm256_castsi128_si256(_mm_loadu_si128((const __m128i *)(src_ptr - 3)));
 108     srcReg32b1 = _mm256_inserti128_si256(
 109         srcReg32b1,
 110         _mm_loadu_si128((const __m128i *)(src_ptr + src_pixels_per_line - 3)),
 111         1);
 112
 113     // filter the source buffer
 114     srcRegFilt32b1_1 = _mm256_shuffle_epi8(srcReg32b1, filt1Reg);
 115     srcRegFilt32b2 = _mm256_shuffle_epi8(srcReg32b1, filt4Reg);
 116
 117     // multiply 2 adjacent elements with the filter and add the result
 118     srcRegFilt32b1_1 = _mm256_maddubs_epi16(srcRegFilt32b1_1, firstFilters);
 119     srcRegFilt32b2 = _mm256_maddubs_epi16(srcRegFilt32b2, forthFilters);
 120
 121     // add and saturate the results together
 122     srcRegFilt32b1_1 = _mm256_adds_epi16(srcRegFilt32b1_1, srcRegFilt32b2);
 123
 124     // filter the source buffer
 125     srcRegFilt32b3 = _mm256_shuffle_epi8(srcReg32b1, filt2Reg);
 126     srcRegFilt32b2 = _mm256_shuffle_epi8(srcReg32b1, filt3Reg);
 127
 128     // multiply 2 adjacent elements with the filter and add the result
 129     srcRegFilt32b3 = _mm256_maddubs_epi16(srcRegFilt32b3, secondFilters);
 130     srcRegFilt32b2 = _mm256_maddubs_epi16(srcRegFilt32b2, thirdFilters);
 131
 132     // add and saturate the results together
 133     srcRegFilt32b1_1 = _mm256_adds_epi16(
 134         srcRegFilt32b1_1, _mm256_min_epi16(srcRegFilt32b3, srcRegFilt32b2));
 135
 136     // reading 2 strides of the next 16 bytes
 137     // (part of it was being read by earlier read)
 138     srcReg32b2 =
 139         _mm256_castsi128_si256(_mm_loadu_si128((const __m128i *)(src_ptr + 5)));
 140     srcReg32b2 = _mm256_inserti128_si256(
 141         srcReg32b2,
 142         _mm_loadu_si128((const __m128i *)(src_ptr + src_pixels_per_line + 5)),
 143         1);
 144
 145     // add and saturate the results together
 146     srcRegFilt32b1_1 = _mm256_adds_epi16(
 147         srcRegFilt32b1_1, _mm256_max_epi16(srcRegFilt32b3, srcRegFilt32b2));
 148
 149     // filter the source buffer
 150     srcRegFilt32b2_1 = _mm256_shuffle_epi8(srcReg32b2, filt1Reg);
 151     srcRegFilt32b2 = _mm256_shuffle_epi8(srcReg32b2, filt4Reg);
 152
 153     // multiply 2 adjacent elements with the filter and add the result
 154     srcRegFilt32b2_1 = _mm256_maddubs_epi16(srcRegFilt32b2_1, firstFilters);
 155     srcRegFilt32b2 = _mm256_maddubs_epi16(srcRegFilt32b2, forthFilters);
 156
 157     // add and saturate the results together
 158     srcRegFilt32b2_1 = _mm256_adds_epi16(srcRegFilt32b2_1, srcRegFilt32b2);
 159
 160     // filter the source buffer
 161     srcRegFilt32b3 = _mm256_shuffle_epi8(srcReg32b2, filt2Reg);
 162     srcRegFilt32b2 = _mm256_shuffle_epi8(srcReg32b2, filt3Reg);
 163
 164     // multiply 2 adjacent elements with the filter and add the result
 165     srcRegFilt32b3 = _mm256_maddubs_epi16(srcRegFilt32b3, secondFilters);
 166     srcRegFilt32b2 = _mm256_maddubs_epi16(srcRegFilt32b2, thirdFilters);
 167
 168     // add and saturate the results together
 169     srcRegFilt32b2_1 = _mm256_adds_epi16(
 170         srcRegFilt32b2_1, _mm256_min_epi16(srcRegFilt32b3, srcRegFilt32b2));
 171     srcRegFilt32b2_1 = _mm256_adds_epi16(
 172         srcRegFilt32b2_1, _mm256_max_epi16(srcRegFilt32b3, srcRegFilt32b2));
 173
 174     srcRegFilt32b1_1 = _mm256_adds_epi16(srcRegFilt32b1_1, addFilterReg64);
 175
 176     srcRegFilt32b2_1 = _mm256_adds_epi16(srcRegFilt32b2_1, addFilterReg64);
 177
 178     // shift by 7 bit each 16 bit
 179     srcRegFilt32b1_1 = _mm256_srai_epi16(srcRegFilt32b1_1, 7);
 180     srcRegFilt32b2_1 = _mm256_srai_epi16(srcRegFilt32b2_1, 7);
 181
 182     // shrink to 8 bit each 16 bits, the first lane contain the first
 183     // convolve result and the second lane contain the second convolve
 184     // result
 185     srcRegFilt32b1_1 = _mm256_packus_epi16(srcRegFilt32b1_1, srcRegFilt32b2_1);
 186
 187     src_ptr += src_stride;
 188
 189     // average if necessary
 190     outReg1 = _mm256_castsi256_si128(srcRegFilt32b1_1);
 191     outReg2 = _mm256_extractf128_si256(srcRegFilt32b1_1, 1);
 192     if (avg) {
 193       outReg1 = _mm_avg_epu8(outReg1, _mm_load_si128((__m128i *)output_ptr));
 194       outReg2 = _mm_avg_epu8(
 195           outReg2, _mm_load_si128((__m128i *)(output_ptr + output_pitch)));
 196     }
 197
 198     // save 16 bytes
 199     _mm_store_si128((__m128i *)output_ptr, outReg1);
 200
 201     // save the next 16 bits
 202     _mm_store_si128((__m128i *)(output_ptr + output_pitch), outReg2);
 203
 204     output_ptr += dst_stride;
 205   }
 206
 207   // if the number of strides is odd.
 208   // process only 16 bytes
 209   if (i > 0) {
 210     __m128i srcReg1, srcReg2, srcRegFilt1_1, srcRegFilt2_1;
 211     __m128i srcRegFilt2, srcRegFilt3;
 212
 213     srcReg1 = _mm_loadu_si128((const __m128i *)(src_ptr - 3));
 214
 215     // filter the source buffer
 216     srcRegFilt1_1 = _mm_shuffle_epi8(srcReg1, _mm256_castsi256_si128(filt1Reg));
 217     srcRegFilt2 = _mm_shuffle_epi8(srcReg1, _mm256_castsi256_si128(filt4Reg));
 218
 219     // multiply 2 adjacent elements with the filter and add the result
 220     srcRegFilt1_1 =
 221         _mm_maddubs_epi16(srcRegFilt1_1, _mm256_castsi256_si128(firstFilters));
 222     srcRegFilt2 =
 223         _mm_maddubs_epi16(srcRegFilt2, _mm256_castsi256_si128(forthFilters));
 224
 225     // add and saturate the results together
 226     srcRegFilt1_1 = _mm_adds_epi16(srcRegFilt1_1, srcRegFilt2);
 227
 228     // filter the source buffer
 229     srcRegFilt3 = _mm_shuffle_epi8(srcReg1, _mm256_castsi256_si128(filt2Reg));
 230     srcRegFilt2 = _mm_shuffle_epi8(srcReg1, _mm256_castsi256_si128(filt3Reg));
 231
 232     // multiply 2 adjacent elements with the filter and add the result
 233     srcRegFilt3 =
 234         _mm_maddubs_epi16(srcRegFilt3, _mm256_castsi256_si128(secondFilters));
 235     srcRegFilt2 =
 236         _mm_maddubs_epi16(srcRegFilt2, _mm256_castsi256_si128(thirdFilters));
 237
 238     // add and saturate the results together
 239     srcRegFilt1_1 =
 240         _mm_adds_epi16(srcRegFilt1_1, _mm_min_epi16(srcRegFilt3, srcRegFilt2));
 241
 242     // reading the next 16 bytes
 243     // (part of it was being read by earlier read)
 244     srcReg2 = _mm_loadu_si128((const __m128i *)(src_ptr + 5));
 245
 246     // add and saturate the results together
 247     srcRegFilt1_1 =
 248         _mm_adds_epi16(srcRegFilt1_1, _mm_max_epi16(srcRegFilt3, srcRegFilt2));
 249
 250     // filter the source buffer
 251     srcRegFilt2_1 = _mm_shuffle_epi8(srcReg2, _mm256_castsi256_si128(filt1Reg));
 252     srcRegFilt2 = _mm_shuffle_epi8(srcReg2, _mm256_castsi256_si128(filt4Reg));
 253
 254     // multiply 2 adjacent elements with the filter and add the result
 255     srcRegFilt2_1 =
 256         _mm_maddubs_epi16(srcRegFilt2_1, _mm256_castsi256_si128(firstFilters));
 257     srcRegFilt2 =
 258         _mm_maddubs_epi16(srcRegFilt2, _mm256_castsi256_si128(forthFilters));
 259
 260     // add and saturate the results together
 261     srcRegFilt2_1 = _mm_adds_epi16(srcRegFilt2_1, srcRegFilt2);
 262
 263     // filter the source buffer
 264     srcRegFilt3 = _mm_shuffle_epi8(srcReg2, _mm256_castsi256_si128(filt2Reg));
 265     srcRegFilt2 = _mm_shuffle_epi8(srcReg2, _mm256_castsi256_si128(filt3Reg));
 266
 267     // multiply 2 adjacent elements with the filter and add the result
 268     srcRegFilt3 =
 269         _mm_maddubs_epi16(srcRegFilt3, _mm256_castsi256_si128(secondFilters));
 270     srcRegFilt2 =
 271         _mm_maddubs_epi16(srcRegFilt2, _mm256_castsi256_si128(thirdFilters));
 272
 273     // add and saturate the results together
 274     srcRegFilt2_1 =
 275         _mm_adds_epi16(srcRegFilt2_1, _mm_min_epi16(srcRegFilt3, srcRegFilt2));
 276     srcRegFilt2_1 =
 277         _mm_adds_epi16(srcRegFilt2_1, _mm_max_epi16(srcRegFilt3, srcRegFilt2));
 278
 279     srcRegFilt1_1 =
 280         _mm_adds_epi16(srcRegFilt1_1, _mm256_castsi256_si128(addFilterReg64));
 281
 282     srcRegFilt2_1 =
 283         _mm_adds_epi16(srcRegFilt2_1, _mm256_castsi256_si128(addFilterReg64));
 284
 285     // shift by 7 bit each 16 bit
 286     srcRegFilt1_1 = _mm_srai_epi16(srcRegFilt1_1, 7);
 287     srcRegFilt2_1 = _mm_srai_epi16(srcRegFilt2_1, 7);
 288
 289     // shrink to 8 bit each 16 bits, the first lane contain the first
 290     // convolve result and the second lane contain the second convolve
 291     // result
 292     outReg1 = _mm_packus_epi16(srcRegFilt1_1, srcRegFilt2_1);
 293
 294     // average if necessary
 295     if (avg) {
 296       outReg1 = _mm_avg_epu8(outReg1, _mm_load_si128((__m128i *)output_ptr));
 297     }
 298
 299     // save 16 bytes
 300     _mm_store_si128((__m128i *)output_ptr, outReg1);
 301   }
 302 }
 303
 304 static void vpx_filter_block1d16_h8_avx2(
 305     const uint8_t *src_ptr, ptrdiff_t src_stride, uint8_t *output_ptr,
 306     ptrdiff_t dst_stride, uint32_t output_height, const int16_t *filter) {
 307   vpx_filter_block1d16_h8_X_avx2(src_ptr, src_stride, output_ptr, dst_stride,
 308                                  output_height, filter, 0);
 309 }
 310
 311 static void vpx_filter_block1d16_h8_avg_avx2(
 312     const uint8_t *src_ptr, ptrdiff_t src_stride, uint8_t *output_ptr,
 313     ptrdiff_t dst_stride, uint32_t output_height, const int16_t *filter) {
 314   vpx_filter_block1d16_h8_X_avx2(src_ptr, src_stride, output_ptr, dst_stride,
 315                                  output_height, filter, 1);
 316 }
 317
 318 static INLINE void vpx_filter_block1d16_v8_X_avx2(
 319     const uint8_t *src_ptr, ptrdiff_t src_pitch, uint8_t *output_ptr,
 320     ptrdiff_t out_pitch, uint32_t output_height, const int16_t *filter,
 321     const int avg) {
 322   __m128i filtersReg, outReg1, outReg2;
 323   __m256i addFilterReg64;
 324   __m256i srcReg32b1, srcReg32b2, srcReg32b3, srcReg32b4, srcReg32b5;
 325   __m256i srcReg32b6, srcReg32b7, srcReg32b8, srcReg32b9, srcReg32b10;
 326   __m256i srcReg32b11, srcReg32b12, filtersReg32;
 327   __m256i firstFilters, secondFilters, thirdFilters, forthFilters;
 328   unsigned int i;
 329   ptrdiff_t src_stride, dst_stride;
 330
 331   // create a register with 0,64,0,64,0,64,0,64,0,64,0,64,0,64,0,64
 332   addFilterReg64 = _mm256_set1_epi32((int)0x0400040u);
 333   filtersReg = _mm_loadu_si128((const __m128i *)filter);
 334   // converting the 16 bit (short) to  8 bit (byte) and have the
 335   // same data in both lanes of 128 bit register.
 336   filtersReg = _mm_packs_epi16(filtersReg, filtersReg);
 337   // have the same data in both lanes of a 256 bit register
 338   filtersReg32 = MM256_BROADCASTSI128_SI256(filtersReg);
 339
 340   // duplicate only the first 16 bits (first and second byte)
 341   // across 256 bit register
 342   firstFilters = _mm256_shuffle_epi8(filtersReg32, _mm256_set1_epi16(0x100u));
 343   // duplicate only the second 16 bits (third and forth byte)
 344   // across 256 bit register
 345   secondFilters = _mm256_shuffle_epi8(filtersReg32, _mm256_set1_epi16(0x302u));
 346   // duplicate only the third 16 bits (fifth and sixth byte)
 347   // across 256 bit register
 348   thirdFilters = _mm256_shuffle_epi8(filtersReg32, _mm256_set1_epi16(0x504u));
 349   // duplicate only the forth 16 bits (seventh and eighth byte)
 350   // across 256 bit register
 351   forthFilters = _mm256_shuffle_epi8(filtersReg32, _mm256_set1_epi16(0x706u));
 352
 353   // multiple the size of the source and destination stride by two
 354   src_stride = src_pitch << 1;
 355   dst_stride = out_pitch << 1;
 356
 357   // load 16 bytes 7 times in stride of src_pitch
 358   srcReg32b1 =
 359       _mm256_castsi128_si256(_mm_loadu_si128((const __m128i *)(src_ptr)));
 360   srcReg32b2 = _mm256_castsi128_si256(
 361       _mm_loadu_si128((const __m128i *)(src_ptr + src_pitch)));
 362   srcReg32b3 = _mm256_castsi128_si256(
 363       _mm_loadu_si128((const __m128i *)(src_ptr + src_pitch * 2)));
 364   srcReg32b4 = _mm256_castsi128_si256(
 365       _mm_loadu_si128((const __m128i *)(src_ptr + src_pitch * 3)));
 366   srcReg32b5 = _mm256_castsi128_si256(
 367       _mm_loadu_si128((const __m128i *)(src_ptr + src_pitch * 4)));
 368   srcReg32b6 = _mm256_castsi128_si256(
 369       _mm_loadu_si128((const __m128i *)(src_ptr + src_pitch * 5)));
 370   srcReg32b7 = _mm256_castsi128_si256(
 371       _mm_loadu_si128((const __m128i *)(src_ptr + src_pitch * 6)));
 372
 373   // have each consecutive loads on the same 256 register
 374   srcReg32b1 = _mm256_inserti128_si256(srcReg32b1,
 375                                        _mm256_castsi256_si128(srcReg32b2), 1);
 376   srcReg32b2 = _mm256_inserti128_si256(srcReg32b2,
 377                                        _mm256_castsi256_si128(srcReg32b3), 1);
 378   srcReg32b3 = _mm256_inserti128_si256(srcReg32b3,
 379                                        _mm256_castsi256_si128(srcReg32b4), 1);
 380   srcReg32b4 = _mm256_inserti128_si256(srcReg32b4,
 381                                        _mm256_castsi256_si128(srcReg32b5), 1);
 382   srcReg32b5 = _mm256_inserti128_si256(srcReg32b5,
 383                                        _mm256_castsi256_si128(srcReg32b6), 1);
 384   srcReg32b6 = _mm256_inserti128_si256(srcReg32b6,
 385                                        _mm256_castsi256_si128(srcReg32b7), 1);
 386
 387   // merge every two consecutive registers except the last one
 388   srcReg32b10 = _mm256_unpacklo_epi8(srcReg32b1, srcReg32b2);
 389   srcReg32b1 = _mm256_unpackhi_epi8(srcReg32b1, srcReg32b2);
 390
 391   // save
 392   srcReg32b11 = _mm256_unpacklo_epi8(srcReg32b3, srcReg32b4);
 393
 394   // save
 395   srcReg32b3 = _mm256_unpackhi_epi8(srcReg32b3, srcReg32b4);
 396
 397   // save
 398   srcReg32b2 = _mm256_unpacklo_epi8(srcReg32b5, srcReg32b6);
 399
 400   // save
 401   srcReg32b5 = _mm256_unpackhi_epi8(srcReg32b5, srcReg32b6);
 402
 403   for (i = output_height; i > 1; i -= 2) {
 404     // load the last 2 loads of 16 bytes and have every two
 405     // consecutive loads in the same 256 bit register
 406     srcReg32b8 = _mm256_castsi128_si256(
 407         _mm_loadu_si128((const __m128i *)(src_ptr + src_pitch * 7)));
 408     srcReg32b7 = _mm256_inserti128_si256(srcReg32b7,
 409                                          _mm256_castsi256_si128(srcReg32b8), 1);
 410     srcReg32b9 = _mm256_castsi128_si256(
 411         _mm_loadu_si128((const __m128i *)(src_ptr + src_pitch * 8)));
 412     srcReg32b8 = _mm256_inserti128_si256(srcReg32b8,
 413                                          _mm256_castsi256_si128(srcReg32b9), 1);
 414
 415     // merge every two consecutive registers
 416     // save
 417     srcReg32b4 = _mm256_unpacklo_epi8(srcReg32b7, srcReg32b8);
 418     srcReg32b7 = _mm256_unpackhi_epi8(srcReg32b7, srcReg32b8);
 419
 420     // multiply 2 adjacent elements with the filter and add the result
 421     srcReg32b10 = _mm256_maddubs_epi16(srcReg32b10, firstFilters);
 422     srcReg32b6 = _mm256_maddubs_epi16(srcReg32b4, forthFilters);
 423
 424     // add and saturate the results together
 425     srcReg32b10 = _mm256_adds_epi16(srcReg32b10, srcReg32b6);
 426
 427     // multiply 2 adjacent elements with the filter and add the result
 428     srcReg32b8 = _mm256_maddubs_epi16(srcReg32b11, secondFilters);
 429     srcReg32b12 = _mm256_maddubs_epi16(srcReg32b2, thirdFilters);
 430
 431     // add and saturate the results together
 432     srcReg32b10 = _mm256_adds_epi16(srcReg32b10,
 433                                     _mm256_min_epi16(srcReg32b8, srcReg32b12));
 434     srcReg32b10 = _mm256_adds_epi16(srcReg32b10,
 435                                     _mm256_max_epi16(srcReg32b8, srcReg32b12));
 436
 437     // multiply 2 adjacent elements with the filter and add the result
 438     srcReg32b1 = _mm256_maddubs_epi16(srcReg32b1, firstFilters);
 439     srcReg32b6 = _mm256_maddubs_epi16(srcReg32b7, forthFilters);
 440
 441     srcReg32b1 = _mm256_adds_epi16(srcReg32b1, srcReg32b6);
 442
 443     // multiply 2 adjacent elements with the filter and add the result
 444     srcReg32b8 = _mm256_maddubs_epi16(srcReg32b3, secondFilters);
 445     srcReg32b12 = _mm256_maddubs_epi16(srcReg32b5, thirdFilters);
 446
 447     // add and saturate the results together
 448     srcReg32b1 = _mm256_adds_epi16(srcReg32b1,
 449                                    _mm256_min_epi16(srcReg32b8, srcReg32b12));
 450     srcReg32b1 = _mm256_adds_epi16(srcReg32b1,
 451                                    _mm256_max_epi16(srcReg32b8, srcReg32b12));
 452
 453     srcReg32b10 = _mm256_adds_epi16(srcReg32b10, addFilterReg64);
 454     srcReg32b1 = _mm256_adds_epi16(srcReg32b1, addFilterReg64);
 455
 456     // shift by 7 bit each 16 bit
 457     srcReg32b10 = _mm256_srai_epi16(srcReg32b10, 7);
 458     srcReg32b1 = _mm256_srai_epi16(srcReg32b1, 7);
 459
 460     // shrink to 8 bit each 16 bits, the first lane contain the first
 461     // convolve result and the second lane contain the second convolve
 462     // result
 463     srcReg32b1 = _mm256_packus_epi16(srcReg32b10, srcReg32b1);
 464
 465     src_ptr += src_stride;
 466
 467     // average if necessary
 468     outReg1 = _mm256_castsi256_si128(srcReg32b1);
 469     outReg2 = _mm256_extractf128_si256(srcReg32b1, 1);
 470     if (avg) {
 471       outReg1 = _mm_avg_epu8(outReg1, _mm_load_si128((__m128i *)output_ptr));
 472       outReg2 = _mm_avg_epu8(
 473           outReg2, _mm_load_si128((__m128i *)(output_ptr + out_pitch)));
 474     }
 475
 476     // save 16 bytes
 477     _mm_store_si128((__m128i *)output_ptr, outReg1);
 478
 479     // save the next 16 bits
 480     _mm_store_si128((__m128i *)(output_ptr + out_pitch), outReg2);
 481
 482     output_ptr += dst_stride;
 483
 484     // save part of the registers for next strides
 485     srcReg32b10 = srcReg32b11;
 486     srcReg32b1 = srcReg32b3;
 487     srcReg32b11 = srcReg32b2;
 488     srcReg32b3 = srcReg32b5;
 489     srcReg32b2 = srcReg32b4;
 490     srcReg32b5 = srcReg32b7;
 491     srcReg32b7 = srcReg32b9;
 492   }
 493   if (i > 0) {
 494     __m128i srcRegFilt1, srcRegFilt3, srcRegFilt4, srcRegFilt5;
 495     __m128i srcRegFilt6, srcRegFilt7, srcRegFilt8;
 496     // load the last 16 bytes
 497     srcRegFilt8 = _mm_loadu_si128((const __m128i *)(src_ptr + src_pitch * 7));
 498
 499     // merge the last 2 results together
 500     srcRegFilt4 =
 501         _mm_unpacklo_epi8(_mm256_castsi256_si128(srcReg32b7), srcRegFilt8);
 502     srcRegFilt7 =
 503         _mm_unpackhi_epi8(_mm256_castsi256_si128(srcReg32b7), srcRegFilt8);
 504
 505     // multiply 2 adjacent elements with the filter and add the result
 506     srcRegFilt1 = _mm_maddubs_epi16(_mm256_castsi256_si128(srcReg32b10),
 507                                     _mm256_castsi256_si128(firstFilters));
 508     srcRegFilt4 =
 509         _mm_maddubs_epi16(srcRegFilt4, _mm256_castsi256_si128(forthFilters));
 510     srcRegFilt3 = _mm_maddubs_epi16(_mm256_castsi256_si128(srcReg32b1),
 511                                     _mm256_castsi256_si128(firstFilters));
 512     srcRegFilt7 =
 513         _mm_maddubs_epi16(srcRegFilt7, _mm256_castsi256_si128(forthFilters));
 514
 515     // add and saturate the results together
 516     srcRegFilt1 = _mm_adds_epi16(srcRegFilt1, srcRegFilt4);
 517     srcRegFilt3 = _mm_adds_epi16(srcRegFilt3, srcRegFilt7);
 518
 519     // multiply 2 adjacent elements with the filter and add the result
 520     srcRegFilt4 = _mm_maddubs_epi16(_mm256_castsi256_si128(srcReg32b11),
 521                                     _mm256_castsi256_si128(secondFilters));
 522     srcRegFilt5 = _mm_maddubs_epi16(_mm256_castsi256_si128(srcReg32b3),
 523                                     _mm256_castsi256_si128(secondFilters));
 524
 525     // multiply 2 adjacent elements with the filter and add the result
 526     srcRegFilt6 = _mm_maddubs_epi16(_mm256_castsi256_si128(srcReg32b2),
 527                                     _mm256_castsi256_si128(thirdFilters));
 528     srcRegFilt7 = _mm_maddubs_epi16(_mm256_castsi256_si128(srcReg32b5),
 529                                     _mm256_castsi256_si128(thirdFilters));
 530
 531     // add and saturate the results together
 532     srcRegFilt1 =
 533         _mm_adds_epi16(srcRegFilt1, _mm_min_epi16(srcRegFilt4, srcRegFilt6));
 534     srcRegFilt3 =
 535         _mm_adds_epi16(srcRegFilt3, _mm_min_epi16(srcRegFilt5, srcRegFilt7));
 536
 537     // add and saturate the results together
 538     srcRegFilt1 =
 539         _mm_adds_epi16(srcRegFilt1, _mm_max_epi16(srcRegFilt4, srcRegFilt6));
 540     srcRegFilt3 =
 541         _mm_adds_epi16(srcRegFilt3, _mm_max_epi16(srcRegFilt5, srcRegFilt7));
 542
 543     srcRegFilt1 =
 544         _mm_adds_epi16(srcRegFilt1, _mm256_castsi256_si128(addFilterReg64));
 545     srcRegFilt3 =
 546         _mm_adds_epi16(srcRegFilt3, _mm256_castsi256_si128(addFilterReg64));
 547
 548     // shift by 7 bit each 16 bit
 549     srcRegFilt1 = _mm_srai_epi16(srcRegFilt1, 7);
 550     srcRegFilt3 = _mm_srai_epi16(srcRegFilt3, 7);
 551
 552     // shrink to 8 bit each 16 bits, the first lane contain the first
 553     // convolve result and the second lane contain the second convolve
 554     // result
 555     outReg1 = _mm_packus_epi16(srcRegFilt1, srcRegFilt3);
 556
 557     // average if necessary
 558     if (avg) {
 559       outReg1 = _mm_avg_epu8(outReg1, _mm_load_si128((__m128i *)output_ptr));
 560     }
 561
 562     // save 16 bytes
 563     _mm_store_si128((__m128i *)output_ptr, outReg1);
 564   }
 565 }
 566
 567 static void vpx_filter_block1d16_v8_avx2(const uint8_t *src_ptr,
 568                                          ptrdiff_t src_stride, uint8_t *dst_ptr,
 569                                          ptrdiff_t dst_stride, uint32_t height,
 570                                          const int16_t *filter) {
 571   vpx_filter_block1d16_v8_X_avx2(src_ptr, src_stride, dst_ptr, dst_stride,
 572                                  height, filter, 0);
 573 }
 574
 575 static void vpx_filter_block1d16_v8_avg_avx2(
 576     const uint8_t *src_ptr, ptrdiff_t src_stride, uint8_t *dst_ptr,
 577     ptrdiff_t dst_stride, uint32_t height, const int16_t *filter) {
 578   vpx_filter_block1d16_v8_X_avx2(src_ptr, src_stride, dst_ptr, dst_stride,
 579                                  height, filter, 1);
 580 }
 581
 582 #if HAVE_AVX2 && HAVE_SSSE3
 583 filter8_1dfunction vpx_filter_block1d4_v8_ssse3;
 584 #if ARCH_X86_64
 585 filter8_1dfunction vpx_filter_block1d8_v8_intrin_ssse3;
 586 filter8_1dfunction vpx_filter_block1d8_h8_intrin_ssse3;
 587 filter8_1dfunction vpx_filter_block1d4_h8_intrin_ssse3;
 588 #define vpx_filter_block1d8_v8_avx2 vpx_filter_block1d8_v8_intrin_ssse3
 589 #define vpx_filter_block1d8_h8_avx2 vpx_filter_block1d8_h8_intrin_ssse3
 590 #define vpx_filter_block1d4_h8_avx2 vpx_filter_block1d4_h8_intrin_ssse3
 591 #else  // ARCH_X86
 592 filter8_1dfunction vpx_filter_block1d8_v8_ssse3;
 593 filter8_1dfunction vpx_filter_block1d8_h8_ssse3;
 594 filter8_1dfunction vpx_filter_block1d4_h8_ssse3;
 595 #define vpx_filter_block1d8_v8_avx2 vpx_filter_block1d8_v8_ssse3
 596 #define vpx_filter_block1d8_h8_avx2 vpx_filter_block1d8_h8_ssse3
 597 #define vpx_filter_block1d4_h8_avx2 vpx_filter_block1d4_h8_ssse3
 598 #endif  // ARCH_X86_64
 599 filter8_1dfunction vpx_filter_block1d8_v8_avg_ssse3;
 600 filter8_1dfunction vpx_filter_block1d8_h8_avg_ssse3;
 601 filter8_1dfunction vpx_filter_block1d4_v8_avg_ssse3;
 602 filter8_1dfunction vpx_filter_block1d4_h8_avg_ssse3;
 603 #define vpx_filter_block1d8_v8_avg_avx2 vpx_filter_block1d8_v8_avg_ssse3
 604 #define vpx_filter_block1d8_h8_avg_avx2 vpx_filter_block1d8_h8_avg_ssse3
 605 #define vpx_filter_block1d4_v8_avg_avx2 vpx_filter_block1d4_v8_avg_ssse3
 606 #define vpx_filter_block1d4_h8_avg_avx2 vpx_filter_block1d4_h8_avg_ssse3
 607 filter8_1dfunction vpx_filter_block1d16_v2_ssse3;
 608 filter8_1dfunction vpx_filter_block1d16_h2_ssse3;
 609 filter8_1dfunction vpx_filter_block1d8_v2_ssse3;
 610 filter8_1dfunction vpx_filter_block1d8_h2_ssse3;
 611 filter8_1dfunction vpx_filter_block1d4_v2_ssse3;
 612 filter8_1dfunction vpx_filter_block1d4_h2_ssse3;
 613 #define vpx_filter_block1d4_v8_avx2 vpx_filter_block1d4_v8_ssse3
 614 #define vpx_filter_block1d16_v2_avx2 vpx_filter_block1d16_v2_ssse3
 615 #define vpx_filter_block1d16_h2_avx2 vpx_filter_block1d16_h2_ssse3
 616 #define vpx_filter_block1d8_v2_avx2 vpx_filter_block1d8_v2_ssse3
 617 #define vpx_filter_block1d8_h2_avx2 vpx_filter_block1d8_h2_ssse3
 618 #define vpx_filter_block1d4_v2_avx2 vpx_filter_block1d4_v2_ssse3
 619 #define vpx_filter_block1d4_h2_avx2 vpx_filter_block1d4_h2_ssse3
 620 filter8_1dfunction vpx_filter_block1d16_v2_avg_ssse3;
 621 filter8_1dfunction vpx_filter_block1d16_h2_avg_ssse3;
 622 filter8_1dfunction vpx_filter_block1d8_v2_avg_ssse3;
 623 filter8_1dfunction vpx_filter_block1d8_h2_avg_ssse3;
 624 filter8_1dfunction vpx_filter_block1d4_v2_avg_ssse3;
 625 filter8_1dfunction vpx_filter_block1d4_h2_avg_ssse3;
 626 #define vpx_filter_block1d16_v2_avg_avx2 vpx_filter_block1d16_v2_avg_ssse3
 627 #define vpx_filter_block1d16_h2_avg_avx2 vpx_filter_block1d16_h2_avg_ssse3
 628 #define vpx_filter_block1d8_v2_avg_avx2 vpx_filter_block1d8_v2_avg_ssse3
 629 #define vpx_filter_block1d8_h2_avg_avx2 vpx_filter_block1d8_h2_avg_ssse3
 630 #define vpx_filter_block1d4_v2_avg_avx2 vpx_filter_block1d4_v2_avg_ssse3
 631 #define vpx_filter_block1d4_h2_avg_avx2 vpx_filter_block1d4_h2_avg_ssse3
 632 // void vpx_convolve8_horiz_avx2(const uint8_t *src, ptrdiff_t src_stride,
 633 //                                uint8_t *dst, ptrdiff_t dst_stride,
 634 //                                const InterpKernel *filter, int x0_q4,
 635 //                                int32_t x_step_q4, int y0_q4, int y_step_q4,
 636 //                                int w, int h);
 637 // void vpx_convolve8_vert_avx2(const uint8_t *src, ptrdiff_t src_stride,
 638 //                               uint8_t *dst, ptrdiff_t dst_stride,
 639 //                               const InterpKernel *filter, int x0_q4,
 640 //                               int32_t x_step_q4, int y0_q4, int y_step_q4,
 641 //                               int w, int h);
 642 // void vpx_convolve8_avg_horiz_avx2(const uint8_t *src, ptrdiff_t src_stride,
 643 //                                    uint8_t *dst, ptrdiff_t dst_stride,
 644 //                                    const InterpKernel *filter, int x0_q4,
 645 //                                    int32_t x_step_q4, int y0_q4,
 646 //                                    int y_step_q4, int w, int h);
 647 // void vpx_convolve8_avg_vert_avx2(const uint8_t *src, ptrdiff_t src_stride,
 648 //                                   uint8_t *dst, ptrdiff_t dst_stride,
 649 //                                   const InterpKernel *filter, int x0_q4,
 650 //                                   int32_t x_step_q4, int y0_q4,
 651 //                                   int y_step_q4, int w, int h);
 652 FUN_CONV_1D(horiz, x0_q4, x_step_q4, h, src, , avx2);
 653 FUN_CONV_1D(vert, y0_q4, y_step_q4, v, src - src_stride * 3, , avx2);
 654 FUN_CONV_1D(avg_horiz, x0_q4, x_step_q4, h, src, avg_, avx2);
 655 FUN_CONV_1D(avg_vert, y0_q4, y_step_q4, v, src - src_stride * 3, avg_, avx2);
 656
 657 // void vpx_convolve8_avx2(const uint8_t *src, ptrdiff_t src_stride,
 658 //                          uint8_t *dst, ptrdiff_t dst_stride,
 659 //                          const InterpKernel *filter, int x0_q4,
 660 //                          int32_t x_step_q4, int y0_q4, int y_step_q4,
 661 //                          int w, int h);
 662 // void vpx_convolve8_avg_avx2(const uint8_t *src, ptrdiff_t src_stride,
 663 //                              uint8_t *dst, ptrdiff_t dst_stride,
 664 //                              const InterpKernel *filter, int x0_q4,
 665 //                              int32_t x_step_q4, int y0_q4, int y_step_q4,
 666 //                              int w, int h);
 667 FUN_CONV_2D(, avx2);
 668 FUN_CONV_2D(avg_, avx2);
 669 #endif  // HAVE_AX2 && HAVE_SSSE3