| /* |
| * Copyright (c) 2016, Alliance for Open Media. All rights reserved |
| * |
| * This source code is subject to the terms of the BSD 2 Clause License and |
| * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License |
| * was not distributed with this source code in the LICENSE file, you can |
| * obtain it at www.aomedia.org/license/software. If the Alliance for Open |
| * Media Patent License 1.0 was not distributed with this source code in the |
| * PATENTS file, you can obtain it at www.aomedia.org/license/patent. |
| */ |
| |
| #include <immintrin.h> // AVX2 |
| |
| #include "config/aom_dsp_rtcd.h" |
| |
| #include "aom_ports/mem.h" |
| |
| /* clang-format off */ |
| DECLARE_ALIGNED(32, static const uint8_t, bilinear_filters_avx2[512]) = { |
| 16, 0, 16, 0, 16, 0, 16, 0, 16, 0, 16, 0, 16, 0, 16, 0, |
| 16, 0, 16, 0, 16, 0, 16, 0, 16, 0, 16, 0, 16, 0, 16, 0, |
| 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, |
| 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, |
| 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, |
| 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, |
| 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, |
| 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, |
| 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, |
| 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, |
| 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, |
| 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, 6, 10, |
| 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, |
| 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, 4, 12, |
| 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, |
| 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, 2, 14, |
| }; |
| /* clang-format on */ |
| |
| #define FILTER_SRC(filter) \ |
| /* filter the source */ \ |
| exp_src_lo = _mm256_maddubs_epi16(exp_src_lo, filter); \ |
| exp_src_hi = _mm256_maddubs_epi16(exp_src_hi, filter); \ |
| \ |
| /* add 8 to source */ \ |
| exp_src_lo = _mm256_add_epi16(exp_src_lo, pw8); \ |
| exp_src_hi = _mm256_add_epi16(exp_src_hi, pw8); \ |
| \ |
| /* divide source by 16 */ \ |
| 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_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)); \ |
| MERGE_WITH_SRC(src_reg, src_next_reg) |
| |
| #define CALC_SUM_SSE_INSIDE_LOOP \ |
| /* expand each byte to 2 bytes */ \ |
| exp_dst_lo = _mm256_unpacklo_epi8(dst_reg, zero_reg); \ |
| exp_dst_hi = _mm256_unpackhi_epi8(dst_reg, zero_reg); \ |
| /* source - dest */ \ |
| exp_src_lo = _mm256_sub_epi16(exp_src_lo, exp_dst_lo); \ |
| exp_src_hi = _mm256_sub_epi16(exp_src_hi, exp_dst_hi); \ |
| /* caculate sum */ \ |
| sum_reg = _mm256_add_epi16(sum_reg, exp_src_lo); \ |
| exp_src_lo = _mm256_madd_epi16(exp_src_lo, exp_src_lo); \ |
| sum_reg = _mm256_add_epi16(sum_reg, exp_src_hi); \ |
| exp_src_hi = _mm256_madd_epi16(exp_src_hi, exp_src_hi); \ |
| /* calculate sse */ \ |
| sse_reg = _mm256_add_epi32(sse_reg, exp_src_lo); \ |
| sse_reg = _mm256_add_epi32(sse_reg, exp_src_hi); |
| |
| // final calculation to sum and sse |
| #define CALC_SUM_AND_SSE \ |
| res_cmp = _mm256_cmpgt_epi16(zero_reg, sum_reg); \ |
| sse_reg_hi = _mm256_srli_si256(sse_reg, 8); \ |
| sum_reg_lo = _mm256_unpacklo_epi16(sum_reg, res_cmp); \ |
| sum_reg_hi = _mm256_unpackhi_epi16(sum_reg, res_cmp); \ |
| sse_reg = _mm256_add_epi32(sse_reg, sse_reg_hi); \ |
| sum_reg = _mm256_add_epi32(sum_reg_lo, sum_reg_hi); \ |
| \ |
| sse_reg_hi = _mm256_srli_si256(sse_reg, 4); \ |
| sum_reg_hi = _mm256_srli_si256(sum_reg, 8); \ |
| \ |
| sse_reg = _mm256_add_epi32(sse_reg, sse_reg_hi); \ |
| sum_reg = _mm256_add_epi32(sum_reg, sum_reg_hi); \ |
| *((int *)sse) = _mm_cvtsi128_si32(_mm256_castsi256_si128(sse_reg)) + \ |
| _mm_cvtsi128_si32(_mm256_extractf128_si256(sse_reg, 1)); \ |
| sum_reg_hi = _mm256_srli_si256(sum_reg, 4); \ |
| sum_reg = _mm256_add_epi32(sum_reg, sum_reg_hi); \ |
| sum = _mm_cvtsi128_si32(_mm256_castsi256_si128(sum_reg)) + \ |
| _mm_cvtsi128_si32(_mm256_extractf128_si256(sum_reg, 1)); |
| |
| // Functions related to sub pixel variance width 16 |
| #define LOAD_SRC_DST_INSERT(src_stride, dst_stride) \ |
| /* load source and destination of 2 rows and insert*/ \ |
| src_reg = _mm256_inserti128_si256( \ |
| _mm256_castsi128_si256(_mm_loadu_si128((__m128i *)(src))), \ |
| _mm_loadu_si128((__m128i *)(src + src_stride)), 1); \ |
| dst_reg = _mm256_inserti128_si256( \ |
| _mm256_castsi128_si256(_mm_loadu_si128((__m128i *)(dst))), \ |
| _mm_loadu_si128((__m128i *)(dst + dst_stride)), 1); |
| |
| #define AVG_NEXT_SRC_INSERT(src_reg, size_stride) \ |
| src_next_reg = _mm256_inserti128_si256( \ |
| _mm256_castsi128_si256(_mm_loadu_si128((__m128i *)(src + size_stride))), \ |
| _mm_loadu_si128((__m128i *)(src + (size_stride << 1))), 1); \ |
| /* average between current and next stride source */ \ |
| src_reg = _mm256_avg_epu8(src_reg, src_next_reg); |
| |
| #define MERGE_NEXT_SRC_INSERT(src_reg, size_stride) \ |
| src_next_reg = _mm256_inserti128_si256( \ |
| _mm256_castsi128_si256(_mm_loadu_si128((__m128i *)(src + size_stride))), \ |
| _mm_loadu_si128((__m128i *)(src + (src_stride + size_stride))), 1); \ |
| MERGE_WITH_SRC(src_reg, src_next_reg) |
| |
| #define LOAD_SRC_NEXT_BYTE_INSERT \ |
| /* load source and another source from next row */ \ |
| src_reg = _mm256_inserti128_si256( \ |
| _mm256_castsi128_si256(_mm_loadu_si128((__m128i *)(src))), \ |
| _mm_loadu_si128((__m128i *)(src + src_stride)), 1); \ |
| /* load source and next row source from 1 byte onwards */ \ |
| src_next_reg = _mm256_inserti128_si256( \ |
| _mm256_castsi128_si256(_mm_loadu_si128((__m128i *)(src + 1))), \ |
| _mm_loadu_si128((__m128i *)(src + src_stride + 1)), 1); |
| |
| #define LOAD_DST_INSERT \ |
| dst_reg = _mm256_inserti128_si256( \ |
| _mm256_castsi128_si256(_mm_loadu_si128((__m128i *)(dst))), \ |
| _mm_loadu_si128((__m128i *)(dst + dst_stride)), 1); |
| |
| #define LOAD_SRC_MERGE_128BIT(filter) \ |
| __m128i src_reg_0 = _mm_loadu_si128((__m128i *)(src)); \ |
| __m128i src_reg_1 = _mm_loadu_si128((__m128i *)(src + 1)); \ |
| __m128i src_lo = _mm_unpacklo_epi8(src_reg_0, src_reg_1); \ |
| __m128i src_hi = _mm_unpackhi_epi8(src_reg_0, src_reg_1); \ |
| __m128i filter_128bit = _mm256_castsi256_si128(filter); \ |
| __m128i pw8_128bit = _mm256_castsi256_si128(pw8); |
| |
| #define FILTER_SRC_128BIT(filter) \ |
| /* filter the source */ \ |
| src_lo = _mm_maddubs_epi16(src_lo, filter); \ |
| src_hi = _mm_maddubs_epi16(src_hi, filter); \ |
| \ |
| /* add 8 to source */ \ |
| src_lo = _mm_add_epi16(src_lo, pw8_128bit); \ |
| src_hi = _mm_add_epi16(src_hi, pw8_128bit); \ |
| \ |
| /* divide source by 16 */ \ |
| src_lo = _mm_srai_epi16(src_lo, 4); \ |
| src_hi = _mm_srai_epi16(src_hi, 4); |
| |
| unsigned int aom_sub_pixel_variance32xh_avx2(const uint8_t *src, int src_stride, |
| int x_offset, int y_offset, |
| const uint8_t *dst, int dst_stride, |
| int height, unsigned int *sse) { |
| __m256i src_reg, dst_reg, exp_src_lo, exp_src_hi, exp_dst_lo, exp_dst_hi; |
| __m256i sse_reg, sum_reg, sse_reg_hi, res_cmp, sum_reg_lo, sum_reg_hi; |
| __m256i zero_reg; |
| 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 |
| // 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 = 4 |
| } else if (y_offset == 4) { |
| __m256i src_next_reg; |
| for (i = 0; i < height; i++) { |
| LOAD_SRC_DST |
| AVG_NEXT_SRC(src_reg, src_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) |
| CALC_SUM_SSE_INSIDE_LOOP |
| src += src_stride; |
| dst += dst_stride; |
| } |
| } |
| // x_offset = 4 and y_offset = 0 |
| } else if (x_offset == 4) { |
| if (y_offset == 0) { |
| __m256i src_next_reg; |
| for (i = 0; i < height; i++) { |
| LOAD_SRC_DST |
| AVG_NEXT_SRC(src_reg, 1) |
| // 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 = 4 and y_offset = 4 |
| } else if (y_offset == 4) { |
| __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++) { |
| 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); |
| // expand each byte to 2 bytes |
| MERGE_WITH_SRC(src_avg, zero_reg) |
| // save current source average |
| CALC_SUM_SSE_INSIDE_LOOP |
| dst += dst_stride; |
| } |
| // x_offset = 4 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) |
| 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) |
| CALC_SUM_SSE_INSIDE_LOOP |
| src += src_stride; |
| dst += dst_stride; |
| } |
| // x_offset = bilin interpolation and y_offset = 4 |
| } else if (y_offset == 4) { |
| __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); |
| MERGE_WITH_SRC(src_pack, zero_reg) |
| CALC_SUM_SSE_INSIDE_LOOP |
| src_pack = src_reg; |
| dst += dst_stride; |
| } |
| // x_offset = bilin interpolation and y_offset = bilin interpolation |
| } else { |
| __m256i xfilter, yfilter, pw8, src_next_reg, src_pack; |
| x_offset <<= 5; |
| xfilter = _mm256_load_si256( |
| (__m256i const *)(bilinear_filters_avx2 + x_offset)); |
| y_offset <<= 5; |
| yfilter = _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)); |
| MERGE_NEXT_SRC(src_reg, 1) |
| |
| FILTER_SRC(xfilter) |
| // 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(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 = src_reg; |
| CALC_SUM_SSE_INSIDE_LOOP |
| dst += dst_stride; |
| } |
| } |
| } |
| CALC_SUM_AND_SSE |
| _mm256_zeroupper(); |
| return sum; |
| } |
| |
| unsigned int aom_sub_pixel_variance16xh_avx2(const uint8_t *src, int src_stride, |
| int x_offset, int y_offset, |
| const uint8_t *dst, int dst_stride, |
| int height, unsigned int *sse) { |
| __m256i src_reg, dst_reg, exp_src_lo, exp_src_hi, exp_dst_lo, exp_dst_hi; |
| __m256i sse_reg, sum_reg, sse_reg_hi, res_cmp, sum_reg_lo, sum_reg_hi; |
| __m256i zero_reg; |
| 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 += 2) { |
| LOAD_SRC_DST_INSERT(src_stride, dst_stride) |
| // expend each byte to 2 bytes |
| MERGE_WITH_SRC(src_reg, zero_reg) |
| CALC_SUM_SSE_INSIDE_LOOP |
| src += (src_stride << 1); |
| dst += (dst_stride << 1); |
| } |
| // x_offset = 0 and y_offset = 4 |
| } else if (y_offset == 4) { |
| __m256i src_next_reg; |
| for (i = 0; i < height; i += 2) { |
| LOAD_SRC_DST_INSERT(src_stride, dst_stride) |
| AVG_NEXT_SRC_INSERT(src_reg, src_stride) |
| // expend each byte to 2 bytes |
| MERGE_WITH_SRC(src_reg, zero_reg) |
| CALC_SUM_SSE_INSIDE_LOOP |
| src += (src_stride << 1); |
| dst += (dst_stride << 1); |
| } |
| // 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 += 2) { |
| LOAD_SRC_DST_INSERT(src_stride, dst_stride) |
| MERGE_NEXT_SRC_INSERT(src_reg, src_stride) |
| FILTER_SRC(filter) |
| CALC_SUM_SSE_INSIDE_LOOP |
| src += (src_stride << 1); |
| dst += (dst_stride << 1); |
| } |
| } |
| // x_offset = 4 and y_offset = 0 |
| } else if (x_offset == 4) { |
| if (y_offset == 0) { |
| __m256i src_next_reg; |
| for (i = 0; i < height; i += 2) { |
| LOAD_SRC_NEXT_BYTE_INSERT |
| LOAD_DST_INSERT |
| /* average between current and next stride source */ |
| src_reg = _mm256_avg_epu8(src_reg, src_next_reg); |
| // expand each byte to 2 bytes |
| MERGE_WITH_SRC(src_reg, zero_reg) |
| CALC_SUM_SSE_INSIDE_LOOP |
| src += (src_stride << 1); |
| dst += (dst_stride << 1); |
| } |
| // x_offset = 4 and y_offset = 4 |
| } else if (y_offset == 4) { |
| __m256i src_next_reg, src_avg, src_temp; |
| // load and insert source and next row source |
| LOAD_SRC_NEXT_BYTE_INSERT |
| src_avg = _mm256_avg_epu8(src_reg, src_next_reg); |
| src += src_stride << 1; |
| for (i = 0; i < height - 2; i += 2) { |
| LOAD_SRC_NEXT_BYTE_INSERT |
| src_next_reg = _mm256_avg_epu8(src_reg, src_next_reg); |
| src_temp = _mm256_permute2x128_si256(src_avg, src_next_reg, 0x21); |
| src_temp = _mm256_avg_epu8(src_avg, src_temp); |
| LOAD_DST_INSERT |
| // expand each byte to 2 bytes |
| MERGE_WITH_SRC(src_temp, zero_reg) |
| // save current source average |
| src_avg = src_next_reg; |
| CALC_SUM_SSE_INSIDE_LOOP |
| dst += dst_stride << 1; |
| src += src_stride << 1; |
| } |
| // last 2 rows processing happens here |
| __m128i src_reg_0 = _mm_loadu_si128((__m128i *)(src)); |
| __m128i src_reg_1 = _mm_loadu_si128((__m128i *)(src + 1)); |
| src_reg_0 = _mm_avg_epu8(src_reg_0, src_reg_1); |
| src_next_reg = _mm256_permute2x128_si256( |
| src_avg, _mm256_castsi128_si256(src_reg_0), 0x21); |
| LOAD_DST_INSERT |
| src_avg = _mm256_avg_epu8(src_avg, src_next_reg); |
| MERGE_WITH_SRC(src_avg, zero_reg) |
| CALC_SUM_SSE_INSIDE_LOOP |
| } else { |
| // x_offset = 4 and y_offset = bilin interpolation |
| __m256i filter, pw8, src_next_reg, src_avg, src_temp; |
| y_offset <<= 5; |
| filter = _mm256_load_si256( |
| (__m256i const *)(bilinear_filters_avx2 + y_offset)); |
| pw8 = _mm256_set1_epi16(8); |
| // load and insert source and next row source |
| LOAD_SRC_NEXT_BYTE_INSERT |
| src_avg = _mm256_avg_epu8(src_reg, src_next_reg); |
| src += src_stride << 1; |
| for (i = 0; i < height - 2; i += 2) { |
| LOAD_SRC_NEXT_BYTE_INSERT |
| src_next_reg = _mm256_avg_epu8(src_reg, src_next_reg); |
| src_temp = _mm256_permute2x128_si256(src_avg, src_next_reg, 0x21); |
| LOAD_DST_INSERT |
| MERGE_WITH_SRC(src_avg, src_temp) |
| // save current source average |
| src_avg = src_next_reg; |
| FILTER_SRC(filter) |
| CALC_SUM_SSE_INSIDE_LOOP |
| dst += dst_stride << 1; |
| src += src_stride << 1; |
| } |
| // last 2 rows processing happens here |
| __m128i src_reg_0 = _mm_loadu_si128((__m128i *)(src)); |
| __m128i src_reg_1 = _mm_loadu_si128((__m128i *)(src + 1)); |
| src_reg_0 = _mm_avg_epu8(src_reg_0, src_reg_1); |
| src_next_reg = _mm256_permute2x128_si256( |
| src_avg, _mm256_castsi128_si256(src_reg_0), 0x21); |
| LOAD_DST_INSERT |
| MERGE_WITH_SRC(src_avg, src_next_reg) |
| FILTER_SRC(filter) |
| CALC_SUM_SSE_INSIDE_LOOP |
| } |
| // 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 += 2) { |
| LOAD_SRC_DST_INSERT(src_stride, dst_stride) |
| MERGE_NEXT_SRC_INSERT(src_reg, 1) |
| FILTER_SRC(filter) |
| CALC_SUM_SSE_INSIDE_LOOP |
| src += (src_stride << 1); |
| dst += (dst_stride << 1); |
| } |
| // x_offset = bilin interpolation and y_offset = 4 |
| } else if (y_offset == 4) { |
| __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); |
| // load and insert source and next row source |
| LOAD_SRC_NEXT_BYTE_INSERT |
| MERGE_WITH_SRC(src_reg, src_next_reg) |
| 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); |
| src += src_stride << 1; |
| for (i = 0; i < height - 2; i += 2) { |
| LOAD_SRC_NEXT_BYTE_INSERT |
| LOAD_DST_INSERT |
| MERGE_WITH_SRC(src_reg, src_next_reg) |
| FILTER_SRC(filter) |
| src_reg = _mm256_packus_epi16(exp_src_lo, exp_src_hi); |
| src_next_reg = _mm256_permute2x128_si256(src_pack, src_reg, 0x21); |
| // average between previous pack to the current |
| src_pack = _mm256_avg_epu8(src_pack, src_next_reg); |
| MERGE_WITH_SRC(src_pack, zero_reg) |
| CALC_SUM_SSE_INSIDE_LOOP |
| src_pack = src_reg; |
| src += src_stride << 1; |
| dst += dst_stride << 1; |
| } |
| // last 2 rows processing happens here |
| LOAD_SRC_MERGE_128BIT(filter) |
| LOAD_DST_INSERT |
| FILTER_SRC_128BIT(filter_128bit) |
| src_reg_0 = _mm_packus_epi16(src_lo, src_hi); |
| src_next_reg = _mm256_permute2x128_si256( |
| src_pack, _mm256_castsi128_si256(src_reg_0), 0x21); |
| // average between previous pack to the current |
| src_pack = _mm256_avg_epu8(src_pack, src_next_reg); |
| MERGE_WITH_SRC(src_pack, zero_reg) |
| CALC_SUM_SSE_INSIDE_LOOP |
| } else { |
| // x_offset = bilin interpolation and y_offset = bilin interpolation |
| __m256i xfilter, yfilter, pw8, src_next_reg, src_pack; |
| x_offset <<= 5; |
| xfilter = _mm256_load_si256( |
| (__m256i const *)(bilinear_filters_avx2 + x_offset)); |
| y_offset <<= 5; |
| yfilter = _mm256_load_si256( |
| (__m256i const *)(bilinear_filters_avx2 + y_offset)); |
| pw8 = _mm256_set1_epi16(8); |
| // load and insert source and next row source |
| LOAD_SRC_NEXT_BYTE_INSERT |
| MERGE_WITH_SRC(src_reg, src_next_reg) |
| FILTER_SRC(xfilter) |
| // 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); |
| src += src_stride << 1; |
| for (i = 0; i < height - 2; i += 2) { |
| LOAD_SRC_NEXT_BYTE_INSERT |
| LOAD_DST_INSERT |
| MERGE_WITH_SRC(src_reg, src_next_reg) |
| FILTER_SRC(xfilter) |
| src_reg = _mm256_packus_epi16(exp_src_lo, exp_src_hi); |
| src_next_reg = _mm256_permute2x128_si256(src_pack, src_reg, 0x21); |
| // average between previous pack to the current |
| MERGE_WITH_SRC(src_pack, src_next_reg) |
| // filter the source |
| FILTER_SRC(yfilter) |
| src_pack = src_reg; |
| CALC_SUM_SSE_INSIDE_LOOP |
| src += src_stride << 1; |
| dst += dst_stride << 1; |
| } |
| // last 2 rows processing happens here |
| LOAD_SRC_MERGE_128BIT(xfilter) |
| LOAD_DST_INSERT |
| FILTER_SRC_128BIT(filter_128bit) |
| src_reg_0 = _mm_packus_epi16(src_lo, src_hi); |
| src_next_reg = _mm256_permute2x128_si256( |
| src_pack, _mm256_castsi128_si256(src_reg_0), 0x21); |
| MERGE_WITH_SRC(src_pack, src_next_reg) |
| FILTER_SRC(yfilter) |
| CALC_SUM_SSE_INSIDE_LOOP |
| } |
| } |
| CALC_SUM_AND_SSE |
| _mm256_zeroupper(); |
| return sum; |
| } |
| |
| unsigned int aom_sub_pixel_avg_variance32xh_avx2( |
| const uint8_t *src, int src_stride, int x_offset, int y_offset, |
| const uint8_t *dst, int dst_stride, const uint8_t *sec, int sec_stride, |
| int height, unsigned int *sse) { |
| __m256i sec_reg; |
| __m256i src_reg, dst_reg, exp_src_lo, exp_src_hi, exp_dst_lo, exp_dst_hi; |
| __m256i sse_reg, sum_reg, sse_reg_hi, res_cmp, sum_reg_lo, sum_reg_hi; |
| __m256i zero_reg; |
| 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_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_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_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_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_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_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_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_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; |
| x_offset <<= 5; |
| xfilter = _mm256_load_si256( |
| (__m256i const *)(bilinear_filters_avx2 + x_offset)); |
| y_offset <<= 5; |
| yfilter = _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)); |
| MERGE_NEXT_SRC(src_reg, 1) |
| |
| FILTER_SRC(xfilter) |
| // 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(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_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 |
| _mm256_zeroupper(); |
| return sum; |
| } |
