libvpx: Pull from upstream

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

 /*
  *  Copyright (c) 2012 The WebM project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 49 matching lines @@
   exp_src_lo = _mm256_srai_epi16(exp_src_lo, 4); \
   exp_src_hi = _mm256_srai_epi16(exp_src_hi, 4);
 
 #define MERGE_WITH_SRC(src_reg, reg) \
   exp_src_lo = _mm256_unpacklo_epi8(src_reg, reg); \
   exp_src_hi = _mm256_unpackhi_epi8(src_reg, reg);
 
 #define LOAD_SRC_DST \
   /* load source and destination */ \
   src_reg = _mm256_loadu_si256((__m256i const *) (src)); \
-  dst_reg = _mm256_load_si256((__m256i const *) (dst));
+  dst_reg = _mm256_loadu_si256((__m256i const *) (dst));
 
 #define AVG_NEXT_SRC(src_reg, size_stride) \
   src_next_reg = _mm256_loadu_si256((__m256i const *) \
                                    (src + size_stride)); \
   /* average between current and next stride source */ \
   src_reg = _mm256_avg_epu8(src_reg, src_next_reg);
 
 #define MERGE_NEXT_SRC(src_reg, size_stride) \
   src_next_reg = _mm256_loadu_si256((__m256i const *) \
                                    (src + size_stride)); \
@@ skipping 245 matching lines @@
   int i, sum;
   sum_reg = _mm256_set1_epi16(0);
   sse_reg = _mm256_set1_epi16(0);
   zero_reg = _mm256_set1_epi16(0);
 
   // x_offset = 0 and y_offset = 0
   if (x_offset == 0) {
     if (y_offset == 0) {
       for (i = 0; i < height ; i++) {
         LOAD_SRC_DST
-        sec_reg = _mm256_load_si256((__m256i const *) (sec));
+        sec_reg = _mm256_loadu_si256((__m256i const *) (sec));
         src_reg = _mm256_avg_epu8(src_reg, sec_reg);
         sec+= sec_stride;
         // expend each byte to 2 bytes
         MERGE_WITH_SRC(src_reg, zero_reg)
         CALC_SUM_SSE_INSIDE_LOOP
         src+= src_stride;
         dst+= dst_stride;
       }
     } else if (y_offset == 8) {
       __m256i src_next_reg;
       for (i = 0; i < height ; i++) {
         LOAD_SRC_DST
         AVG_NEXT_SRC(src_reg, src_stride)
-        sec_reg = _mm256_load_si256((__m256i const *) (sec));
+        sec_reg = _mm256_loadu_si256((__m256i const *) (sec));
         src_reg = _mm256_avg_epu8(src_reg, sec_reg);
         sec+= sec_stride;
         // expend each byte to 2 bytes
         MERGE_WITH_SRC(src_reg, zero_reg)
         CALC_SUM_SSE_INSIDE_LOOP
         src+= src_stride;
         dst+= dst_stride;
       }
     // x_offset = 0 and y_offset = bilin interpolation
     } else {
       __m256i filter, pw8, src_next_reg;
 
       y_offset <<= 5;
       filter = _mm256_load_si256((__m256i const *)
                  (bilinear_filters_avx2 + y_offset));
       pw8 = _mm256_set1_epi16(8);
       for (i = 0; i < height ; i++) {
         LOAD_SRC_DST
         MERGE_NEXT_SRC(src_reg, src_stride)
         FILTER_SRC(filter)
         src_reg = _mm256_packus_epi16(exp_src_lo, exp_src_hi);
-        sec_reg = _mm256_load_si256((__m256i const *) (sec));
+        sec_reg = _mm256_loadu_si256((__m256i const *) (sec));
         src_reg = _mm256_avg_epu8(src_reg, sec_reg);
         sec+= sec_stride;
         MERGE_WITH_SRC(src_reg, zero_reg)
         CALC_SUM_SSE_INSIDE_LOOP
         src+= src_stride;
         dst+= dst_stride;
       }
     }
   // x_offset = 8  and y_offset = 0
   } else if (x_offset == 8) {
     if (y_offset == 0) {
       __m256i src_next_reg;
       for (i = 0; i < height ; i++) {
         LOAD_SRC_DST
         AVG_NEXT_SRC(src_reg, 1)
-        sec_reg = _mm256_load_si256((__m256i const *) (sec));
+        sec_reg = _mm256_loadu_si256((__m256i const *) (sec));
         src_reg = _mm256_avg_epu8(src_reg, sec_reg);
         sec+= sec_stride;
         // expand each byte to 2 bytes
         MERGE_WITH_SRC(src_reg, zero_reg)
         CALC_SUM_SSE_INSIDE_LOOP
         src+= src_stride;
         dst+= dst_stride;
       }
     // x_offset = 8  and y_offset = 8
     } else if (y_offset == 8) {
       __m256i src_next_reg, src_avg;
       // load source and another source starting from the next
       // following byte
       src_reg = _mm256_loadu_si256((__m256i const *) (src));
       AVG_NEXT_SRC(src_reg, 1)
       for (i = 0; i < height ; i++) {
         // save current source average
         src_avg = src_reg;
         src+= src_stride;
         LOAD_SRC_DST
         AVG_NEXT_SRC(src_reg, 1)
         // average between previous average to current average
         src_avg = _mm256_avg_epu8(src_avg, src_reg);
-        sec_reg = _mm256_load_si256((__m256i const *) (sec));
+        sec_reg = _mm256_loadu_si256((__m256i const *) (sec));
         src_avg = _mm256_avg_epu8(src_avg, sec_reg);
         sec+= sec_stride;
         // expand each byte to 2 bytes
         MERGE_WITH_SRC(src_avg, zero_reg)
         CALC_SUM_SSE_INSIDE_LOOP
         dst+= dst_stride;
       }
     // x_offset = 8  and y_offset = bilin interpolation
     } else {
       __m256i filter, pw8, src_next_reg, src_avg;
       y_offset <<= 5;
       filter = _mm256_load_si256((__m256i const *)
                (bilinear_filters_avx2 + y_offset));
       pw8 = _mm256_set1_epi16(8);
       // load source and another source starting from the next
       // following byte
       src_reg = _mm256_loadu_si256((__m256i const *) (src));
       AVG_NEXT_SRC(src_reg, 1)
       for (i = 0; i < height ; i++) {
         // save current source average
         src_avg = src_reg;
         src+= src_stride;
         LOAD_SRC_DST
         AVG_NEXT_SRC(src_reg, 1)
         MERGE_WITH_SRC(src_avg, src_reg)
         FILTER_SRC(filter)
         src_avg = _mm256_packus_epi16(exp_src_lo, exp_src_hi);
-        sec_reg = _mm256_load_si256((__m256i const *) (sec));
+        sec_reg = _mm256_loadu_si256((__m256i const *) (sec));
         src_avg = _mm256_avg_epu8(src_avg, sec_reg);
         // expand each byte to 2 bytes
         MERGE_WITH_SRC(src_avg, zero_reg)
         sec+= sec_stride;
         CALC_SUM_SSE_INSIDE_LOOP
         dst+= dst_stride;
       }
     }
   // x_offset = bilin interpolation and y_offset = 0
   } else {
     if (y_offset == 0) {
       __m256i filter, pw8, src_next_reg;
       x_offset <<= 5;
       filter = _mm256_load_si256((__m256i const *)
                (bilinear_filters_avx2 + x_offset));
       pw8 = _mm256_set1_epi16(8);
       for (i = 0; i < height ; i++) {
         LOAD_SRC_DST
         MERGE_NEXT_SRC(src_reg, 1)
         FILTER_SRC(filter)
         src_reg = _mm256_packus_epi16(exp_src_lo, exp_src_hi);
-        sec_reg = _mm256_load_si256((__m256i const *) (sec));
+        sec_reg = _mm256_loadu_si256((__m256i const *) (sec));
         src_reg = _mm256_avg_epu8(src_reg, sec_reg);
         MERGE_WITH_SRC(src_reg, zero_reg)
         sec+= sec_stride;
         CALC_SUM_SSE_INSIDE_LOOP
         src+= src_stride;
         dst+= dst_stride;
       }
     // x_offset = bilin interpolation and y_offset = 8
     } else if (y_offset == 8) {
       __m256i filter, pw8, src_next_reg, src_pack;
       x_offset <<= 5;
       filter = _mm256_load_si256((__m256i const *)
                (bilinear_filters_avx2 + x_offset));
       pw8 = _mm256_set1_epi16(8);
       src_reg = _mm256_loadu_si256((__m256i const *) (src));
       MERGE_NEXT_SRC(src_reg, 1)
       FILTER_SRC(filter)
       // convert each 16 bit to 8 bit to each low and high lane source
       src_pack =  _mm256_packus_epi16(exp_src_lo, exp_src_hi);
       for (i = 0; i < height ; i++) {
         src+= src_stride;
         LOAD_SRC_DST
         MERGE_NEXT_SRC(src_reg, 1)
         FILTER_SRC(filter)
         src_reg =  _mm256_packus_epi16(exp_src_lo, exp_src_hi);
         // average between previous pack to the current
         src_pack = _mm256_avg_epu8(src_pack, src_reg);
-        sec_reg = _mm256_load_si256((__m256i const *) (sec));
+        sec_reg = _mm256_loadu_si256((__m256i const *) (sec));
         src_pack = _mm256_avg_epu8(src_pack, sec_reg);
         sec+= sec_stride;
         MERGE_WITH_SRC(src_pack, zero_reg)
         src_pack = src_reg;
         CALC_SUM_SSE_INSIDE_LOOP
         dst+= dst_stride;
       }
     // x_offset = bilin interpolation and y_offset = bilin interpolation
     } else {
       __m256i xfilter, yfilter, pw8, src_next_reg, src_pack;
@@ skipping 16 matching lines @@
         src+= src_stride;
         LOAD_SRC_DST
         MERGE_NEXT_SRC(src_reg, 1)
         FILTER_SRC(xfilter)
         src_reg = _mm256_packus_epi16(exp_src_lo, exp_src_hi);
         // merge previous pack to current pack source
         MERGE_WITH_SRC(src_pack, src_reg)
         // filter the source
         FILTER_SRC(yfilter)
         src_pack = _mm256_packus_epi16(exp_src_lo, exp_src_hi);
-        sec_reg = _mm256_load_si256((__m256i const *) (sec));
+        sec_reg = _mm256_loadu_si256((__m256i const *) (sec));
         src_pack = _mm256_avg_epu8(src_pack, sec_reg);
         MERGE_WITH_SRC(src_pack, zero_reg)
         src_pack = src_reg;
         sec+= sec_stride;
         CALC_SUM_SSE_INSIDE_LOOP
         dst+= dst_stride;
       }
     }
   }
   CALC_SUM_AND_SSE
   return sum;
 }