2014-11-20 16:38:54 +00:00
|
|
|
/*****************************************************************************
|
|
|
|
* This file is part of Kvazaar HEVC encoder.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2013-2014 Tampere University of Technology and others (see
|
|
|
|
* COPYING file).
|
|
|
|
*
|
|
|
|
* Kvazaar is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as published
|
|
|
|
* by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* Kvazaar is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with Kvazaar. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* \file
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
|
|
|
#include "ipol-avx2.h"
|
|
|
|
#include "strategyselector.h"
|
|
|
|
#include "encoder.h"
|
2015-02-05 11:28:07 +00:00
|
|
|
#include "strategies/generic/picture-generic.h"
|
2014-11-20 16:38:54 +00:00
|
|
|
|
2014-12-11 14:38:43 +00:00
|
|
|
extern int8_t g_luma_filter[4][8];
|
|
|
|
extern int8_t g_chroma_filter[8][4];
|
2014-11-20 16:38:54 +00:00
|
|
|
|
2015-02-05 11:28:07 +00:00
|
|
|
int16_t eight_tap_filter_hor_avx2(int8_t *filter, pixel *data)
|
|
|
|
{
|
|
|
|
int16_t temp = 0;
|
|
|
|
for (int i = 0; i < 8; ++i)
|
|
|
|
{
|
|
|
|
temp += filter[i] * data[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
return temp;
|
|
|
|
}
|
|
|
|
|
|
|
|
int32_t eight_tap_filter_hor_16bit_avx2(int8_t *filter, int16_t *data)
|
|
|
|
{
|
|
|
|
int32_t temp = 0;
|
|
|
|
for (int i = 0; i < 8; ++i)
|
|
|
|
{
|
|
|
|
temp += filter[i] * data[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
return temp;
|
|
|
|
}
|
|
|
|
|
|
|
|
int16_t eight_tap_filter_ver_avx2(int8_t *filter, pixel *data, int16_t stride)
|
|
|
|
{
|
|
|
|
int16_t temp = 0;
|
|
|
|
for (int i = 0; i < 8; ++i)
|
|
|
|
{
|
|
|
|
temp += filter[i] * data[stride * i];
|
|
|
|
}
|
|
|
|
|
|
|
|
return temp;
|
|
|
|
}
|
|
|
|
|
|
|
|
int32_t eight_tap_filter_ver_16bit_avx2(int8_t *filter, int16_t *data, int16_t stride)
|
|
|
|
{
|
|
|
|
int32_t temp = 0;
|
|
|
|
for (int i = 0; i < 8; ++i)
|
|
|
|
{
|
|
|
|
temp += filter[i] * data[stride * i];
|
|
|
|
}
|
|
|
|
|
|
|
|
return temp;
|
|
|
|
}
|
|
|
|
|
|
|
|
int16_t four_tap_filter_hor_avx2(int8_t *filter, pixel *data)
|
|
|
|
{
|
|
|
|
int16_t temp = 0;
|
|
|
|
for (int i = 0; i < 4; ++i)
|
|
|
|
{
|
|
|
|
temp += filter[i] * data[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
return temp;
|
|
|
|
}
|
|
|
|
|
|
|
|
int32_t four_tap_filter_hor_16bit_avx2(int8_t *filter, int16_t *data)
|
|
|
|
{
|
|
|
|
int32_t temp = 0;
|
|
|
|
for (int i = 0; i < 4; ++i)
|
|
|
|
{
|
|
|
|
temp += filter[i] * data[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
return temp;
|
|
|
|
}
|
|
|
|
|
|
|
|
int16_t four_tap_filter_ver_avx2(int8_t *filter, pixel *data, int16_t stride)
|
|
|
|
{
|
|
|
|
int16_t temp = 0;
|
|
|
|
for (int i = 0; i < 4; ++i)
|
|
|
|
{
|
|
|
|
temp += filter[i] * data[stride * i];
|
|
|
|
}
|
|
|
|
|
|
|
|
return temp;
|
|
|
|
}
|
|
|
|
|
|
|
|
int32_t four_tap_filter_ver_16bit_avx2(int8_t *filter, int16_t *data, int16_t stride)
|
|
|
|
{
|
|
|
|
int32_t temp = 0;
|
|
|
|
for (int i = 0; i < 4; ++i)
|
|
|
|
{
|
|
|
|
temp += filter[i] * data[stride * i];
|
|
|
|
}
|
|
|
|
|
|
|
|
return temp;
|
|
|
|
}
|
|
|
|
|
|
|
|
void filter_inter_quarterpel_luma_avx2(const encoder_control * const encoder, pixel *src, int16_t src_stride, int width, int height, pixel *dst, int16_t dst_stride, int8_t hor_flag, int8_t ver_flag)
|
2014-11-20 16:38:54 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
int32_t x, y;
|
2015-02-05 11:28:07 +00:00
|
|
|
int32_t shift1 = BIT_DEPTH - 8;
|
2014-11-20 16:38:54 +00:00
|
|
|
int32_t shift2 = 6;
|
2015-02-05 11:28:07 +00:00
|
|
|
int32_t shift3 = 14 - BIT_DEPTH;
|
2014-11-20 16:38:54 +00:00
|
|
|
int32_t offset3 = 1 << (shift3 - 1);
|
|
|
|
int32_t offset23 = 1 << (shift2 + shift3 - 1);
|
|
|
|
|
|
|
|
//coefficients for 1/4, 2/4 and 3/4 positions
|
2015-02-05 11:28:07 +00:00
|
|
|
int8_t *c1, *c2, *c3;
|
2014-11-20 16:38:54 +00:00
|
|
|
|
|
|
|
int i;
|
2015-02-05 11:28:07 +00:00
|
|
|
c1 = g_luma_filter[1];
|
|
|
|
c2 = g_luma_filter[2];
|
|
|
|
c3 = g_luma_filter[3];
|
|
|
|
|
|
|
|
int16_t temp[3][8];
|
2014-11-20 16:38:54 +00:00
|
|
|
|
|
|
|
// Loop source pixels and generate sixteen filtered quarter-pel pixels on each round
|
|
|
|
for (y = 0; y < height; y++) {
|
|
|
|
int dst_pos_y = (y << 2)*dst_stride;
|
|
|
|
int src_pos_y = y*src_stride;
|
|
|
|
for (x = 0; x < width; x++) {
|
|
|
|
// Calculate current dst and src pixel positions
|
|
|
|
int dst_pos = dst_pos_y + (x << 2);
|
|
|
|
int src_pos = src_pos_y + x;
|
|
|
|
|
|
|
|
// Original pixel
|
|
|
|
dst[dst_pos] = src[src_pos];
|
|
|
|
|
|
|
|
//
|
2015-02-05 11:28:07 +00:00
|
|
|
if (hor_flag && !ver_flag) {
|
2014-11-20 16:38:54 +00:00
|
|
|
|
2015-02-05 11:28:07 +00:00
|
|
|
temp[0][3] = eight_tap_filter_hor_avx2(c1, &src[src_pos - 3]) >> shift1;
|
|
|
|
temp[1][3] = eight_tap_filter_hor_avx2(c2, &src[src_pos - 3]) >> shift1;
|
|
|
|
temp[2][3] = eight_tap_filter_hor_avx2(c3, &src[src_pos - 3]) >> shift1;
|
2014-11-20 16:38:54 +00:00
|
|
|
}
|
|
|
|
// ea0,0 - needed only when ver_flag
|
|
|
|
if (ver_flag) {
|
2015-02-05 11:28:07 +00:00
|
|
|
dst[dst_pos + 1 * dst_stride] = fast_clip_16bit_to_pixel(((eight_tap_filter_ver_avx2(c1, &src[src_pos - 3 * src_stride], src_stride) >> shift1) + (1 << (shift3 - 1))) >> shift3);
|
|
|
|
dst[dst_pos + 2 * dst_stride] = fast_clip_16bit_to_pixel(((eight_tap_filter_ver_avx2(c2, &src[src_pos - 3 * src_stride], src_stride) >> shift1) + (1 << (shift3 - 1))) >> shift3);
|
|
|
|
dst[dst_pos + 3 * dst_stride] = fast_clip_16bit_to_pixel(((eight_tap_filter_ver_avx2(c3, &src[src_pos - 3 * src_stride], src_stride) >> shift1) + (1 << (shift3 - 1))) >> shift3);
|
2014-11-20 16:38:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// When both flags, we use _only_ this pixel (but still need ae0,0 for it)
|
|
|
|
if (hor_flag && ver_flag) {
|
|
|
|
|
|
|
|
// Calculate temporary values..
|
|
|
|
src_pos -= 3 * src_stride; //0,-3
|
2015-02-05 11:28:07 +00:00
|
|
|
for (i = 0; i < 8; ++i) {
|
|
|
|
|
|
|
|
temp[0][i] = eight_tap_filter_hor_avx2(c1, &src[src_pos + i * src_stride - 3]) >> shift1; // h0(0,-3+i)
|
|
|
|
temp[1][i] = eight_tap_filter_hor_avx2(c2, &src[src_pos + i * src_stride - 3]) >> shift1; // h1(0,-3+i)
|
|
|
|
temp[2][i] = eight_tap_filter_hor_avx2(c3, &src[src_pos + i * src_stride - 3]) >> shift1; // h2(0,-3+i)
|
2014-11-20 16:38:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
for (i = 0; i<3; ++i){
|
2015-02-05 11:28:07 +00:00
|
|
|
dst[dst_pos + 1 * dst_stride + i + 1] = fast_clip_32bit_to_pixel(((eight_tap_filter_hor_16bit_avx2(c1, &temp[i][0]) + offset23) >> shift2) >> shift3);
|
|
|
|
dst[dst_pos + 2 * dst_stride + i + 1] = fast_clip_32bit_to_pixel(((eight_tap_filter_hor_16bit_avx2(c2, &temp[i][0]) + offset23) >> shift2) >> shift3);
|
|
|
|
dst[dst_pos + 3 * dst_stride + i + 1] = fast_clip_32bit_to_pixel(((eight_tap_filter_hor_16bit_avx2(c3, &temp[i][0]) + offset23) >> shift2) >> shift3);
|
2014-11-20 16:38:54 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
if (hor_flag) {
|
2015-02-05 11:28:07 +00:00
|
|
|
dst[dst_pos + 1] = fast_clip_32bit_to_pixel((temp[0][3] + offset3) >> shift3);
|
|
|
|
dst[dst_pos + 2] = fast_clip_32bit_to_pixel((temp[1][3] + offset3) >> shift3);
|
|
|
|
dst[dst_pos + 3] = fast_clip_32bit_to_pixel((temp[2][3] + offset3) >> shift3);
|
2014-11-20 16:38:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2015-02-05 11:28:07 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* \brief Interpolation for chroma half-pixel
|
|
|
|
* \param src source image in integer pels (-2..width+3, -2..height+3)
|
|
|
|
* \param src_stride stride of source image
|
|
|
|
* \param width width of source image block
|
|
|
|
* \param height height of source image block
|
|
|
|
* \param dst destination image in half-pixel resolution
|
|
|
|
* \param dst_stride stride of destination image
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void filter_inter_halfpel_chroma_avx2(const encoder_control * const encoder, pixel *src, int16_t src_stride, int width, int height, pixel *dst, int16_t dst_stride, int8_t hor_flag, int8_t ver_flag)
|
2014-11-20 16:38:54 +00:00
|
|
|
{
|
|
|
|
/* ____________
|
|
|
|
* | B0,0|ae0,0|
|
|
|
|
* |ea0,0|ee0,0|
|
|
|
|
*
|
|
|
|
* ae0,0 = (-4*B-1,0 + 36*B0,0 + 36*B1,0 - 4*B2,0) >> shift1
|
|
|
|
* ea0,0 = (-4*B0,-1 + 36*B0,0 + 36*B0,1 - 4*B0,2) >> shift1
|
|
|
|
* ee0,0 = (-4*ae0,-1 + 36*ae0,0 + 36*ae0,1 - 4*ae0,2) >> shift2
|
|
|
|
*/
|
|
|
|
int32_t x, y;
|
2015-02-05 11:28:07 +00:00
|
|
|
int32_t shift1 = BIT_DEPTH - 8;
|
2014-11-20 16:38:54 +00:00
|
|
|
int32_t shift2 = 6;
|
2015-02-05 11:28:07 +00:00
|
|
|
int32_t shift3 = 14 - BIT_DEPTH;
|
2014-11-20 16:38:54 +00:00
|
|
|
int32_t offset3 = 1 << (shift3 - 1);
|
|
|
|
int32_t offset23 = 1 << (shift2 + shift3 - 1);
|
|
|
|
|
2015-02-05 11:28:07 +00:00
|
|
|
int8_t* c = g_chroma_filter[4];
|
|
|
|
int16_t temp[4];
|
|
|
|
|
2014-11-20 16:38:54 +00:00
|
|
|
// Loop source pixels and generate four filtered half-pel pixels on each round
|
|
|
|
for (y = 0; y < height; y++) {
|
|
|
|
int dst_pos_y = (y << 1)*dst_stride;
|
|
|
|
int src_pos_y = y*src_stride;
|
|
|
|
for (x = 0; x < width; x++) {
|
|
|
|
// Calculate current dst and src pixel positions
|
|
|
|
int dst_pos = dst_pos_y + (x << 1);
|
|
|
|
int src_pos = src_pos_y + x;
|
|
|
|
|
|
|
|
// Original pixel (not really needed)
|
|
|
|
dst[dst_pos] = src[src_pos]; //B0,0
|
|
|
|
|
|
|
|
// ae0,0 - We need this only when hor_flag and for ee0,0
|
|
|
|
if (hor_flag) {
|
2015-02-05 11:28:07 +00:00
|
|
|
temp[1] = four_tap_filter_hor_avx2(c, &src[src_pos - 1]) >> shift1; // ae0,0
|
2014-11-20 16:38:54 +00:00
|
|
|
}
|
|
|
|
// ea0,0 - needed only when ver_flag
|
|
|
|
if (ver_flag) {
|
2015-02-05 11:28:07 +00:00
|
|
|
dst[dst_pos + 1 * dst_stride] = fast_clip_32bit_to_pixel(((four_tap_filter_ver_avx2(c, &src[src_pos - src_stride], src_stride) >> shift1) + (1 << (shift3 - 1))) >> shift3); // ea0,0
|
2014-11-20 16:38:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// When both flags, we use _only_ this pixel (but still need ae0,0 for it)
|
|
|
|
if (hor_flag && ver_flag) {
|
|
|
|
// Calculate temporary values..
|
|
|
|
src_pos -= src_stride; //0,-1
|
2015-02-05 11:28:07 +00:00
|
|
|
temp[0] = (four_tap_filter_hor_avx2(c, &src[src_pos - 1]) >> shift1); // ae0,-1
|
2014-11-20 16:38:54 +00:00
|
|
|
src_pos += 2 * src_stride; //0,1
|
2015-02-05 11:28:07 +00:00
|
|
|
temp[2] = (four_tap_filter_hor_avx2(c, &src[src_pos - 1]) >> shift1); // ae0,1
|
2014-11-20 16:38:54 +00:00
|
|
|
src_pos += src_stride; //0,2
|
2015-02-05 11:28:07 +00:00
|
|
|
temp[3] = (four_tap_filter_hor_avx2(c, &src[src_pos - 1]) >> shift1); // ae0,2
|
2014-11-20 16:38:54 +00:00
|
|
|
|
2015-02-05 11:28:07 +00:00
|
|
|
dst[dst_pos + 1 * dst_stride + 1] = fast_clip_32bit_to_pixel(((four_tap_filter_hor_16bit_avx2(c, temp) + offset23) >> shift2) >> shift3); // ee0,0
|
2014-11-20 16:38:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (hor_flag) {
|
2015-02-05 11:28:07 +00:00
|
|
|
dst[dst_pos + 1] = fast_clip_32bit_to_pixel((temp[1] + offset3) >> shift3);
|
2014-11-20 16:38:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-05 11:28:07 +00:00
|
|
|
void filter_inter_octpel_chroma_avx2(const encoder_control * const encoder, pixel *src, int16_t src_stride, int width, int height, pixel *dst, int16_t dst_stride, int8_t hor_flag, int8_t ver_flag)
|
2014-11-20 16:38:54 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
int32_t x, y;
|
2015-02-05 11:28:07 +00:00
|
|
|
int32_t shift1 = BIT_DEPTH - 8;
|
2014-11-20 16:38:54 +00:00
|
|
|
int32_t shift2 = 6;
|
2015-02-05 11:28:07 +00:00
|
|
|
int32_t shift3 = 14 - BIT_DEPTH;
|
2014-11-20 16:38:54 +00:00
|
|
|
int32_t offset3 = 1 << (shift3 - 1);
|
|
|
|
int32_t offset23 = 1 << (shift2 + shift3 - 1);
|
|
|
|
|
|
|
|
//coefficients for 1/8, 2/8, 3/8, 4/8, 5/8, 6/8 and 7/8 positions
|
2015-02-05 11:28:07 +00:00
|
|
|
int8_t *c1, *c2, *c3, *c4, *c5, *c6, *c7;
|
2014-11-20 16:38:54 +00:00
|
|
|
|
|
|
|
int i;
|
2015-02-05 11:28:07 +00:00
|
|
|
c1 = g_chroma_filter[1];
|
|
|
|
c2 = g_chroma_filter[2];
|
|
|
|
c3 = g_chroma_filter[3];
|
|
|
|
c4 = g_chroma_filter[4];
|
|
|
|
c5 = g_chroma_filter[5];
|
|
|
|
c6 = g_chroma_filter[6];
|
|
|
|
c7 = g_chroma_filter[7];
|
|
|
|
|
|
|
|
int16_t temp[7][4]; // Temporary horizontal values calculated from integer pixels
|
|
|
|
|
2014-11-20 16:38:54 +00:00
|
|
|
|
|
|
|
// Loop source pixels and generate 64 filtered 1/8-pel pixels on each round
|
|
|
|
for (y = 0; y < height; y++) {
|
|
|
|
int dst_pos_y = (y << 3)*dst_stride;
|
|
|
|
int src_pos_y = y*src_stride;
|
|
|
|
for (x = 0; x < width; x++) {
|
|
|
|
// Calculate current dst and src pixel positions
|
|
|
|
int dst_pos = dst_pos_y + (x << 3);
|
|
|
|
int src_pos = src_pos_y + x;
|
|
|
|
|
|
|
|
// Original pixel
|
|
|
|
dst[dst_pos] = src[src_pos];
|
|
|
|
|
|
|
|
// Horizontal 1/8-values
|
2015-02-05 11:28:07 +00:00
|
|
|
if (hor_flag && !ver_flag) {
|
|
|
|
|
|
|
|
temp[0][1] = (four_tap_filter_hor_avx2(c1, &src[src_pos - 1]) >> shift1); // ae0,0 h0
|
|
|
|
temp[1][1] = (four_tap_filter_hor_avx2(c2, &src[src_pos - 1]) >> shift1);
|
|
|
|
temp[2][1] = (four_tap_filter_hor_avx2(c3, &src[src_pos - 1]) >> shift1);
|
|
|
|
temp[3][1] = (four_tap_filter_hor_avx2(c4, &src[src_pos - 1]) >> shift1);
|
|
|
|
temp[4][1] = (four_tap_filter_hor_avx2(c5, &src[src_pos - 1]) >> shift1);
|
|
|
|
temp[5][1] = (four_tap_filter_hor_avx2(c6, &src[src_pos - 1]) >> shift1);
|
|
|
|
temp[6][1] = (four_tap_filter_hor_avx2(c7, &src[src_pos - 1]) >> shift1);
|
2014-11-20 16:38:54 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
// Vertical 1/8-values
|
|
|
|
if (ver_flag) {
|
2015-02-05 11:28:07 +00:00
|
|
|
dst[dst_pos + 1 * dst_stride] = fast_clip_32bit_to_pixel(((four_tap_filter_ver_avx2(c1, &src[src_pos - 1 * src_stride], src_stride) >> shift1) + (1 << (shift3 - 1))) >> shift3); //
|
|
|
|
dst[dst_pos + 2 * dst_stride] = fast_clip_32bit_to_pixel(((four_tap_filter_ver_avx2(c2, &src[src_pos - 1 * src_stride], src_stride) >> shift1) + (1 << (shift3 - 1))) >> shift3);
|
|
|
|
dst[dst_pos + 3 * dst_stride] = fast_clip_32bit_to_pixel(((four_tap_filter_ver_avx2(c3, &src[src_pos - 1 * src_stride], src_stride) >> shift1) + (1 << (shift3 - 1))) >> shift3);
|
|
|
|
dst[dst_pos + 4 * dst_stride] = fast_clip_32bit_to_pixel(((four_tap_filter_ver_avx2(c4, &src[src_pos - 1 * src_stride], src_stride) >> shift1) + (1 << (shift3 - 1))) >> shift3);
|
|
|
|
dst[dst_pos + 5 * dst_stride] = fast_clip_32bit_to_pixel(((four_tap_filter_ver_avx2(c5, &src[src_pos - 1 * src_stride], src_stride) >> shift1) + (1 << (shift3 - 1))) >> shift3);
|
|
|
|
dst[dst_pos + 6 * dst_stride] = fast_clip_32bit_to_pixel(((four_tap_filter_ver_avx2(c6, &src[src_pos - 1 * src_stride], src_stride) >> shift1) + (1 << (shift3 - 1))) >> shift3);
|
|
|
|
dst[dst_pos + 7 * dst_stride] = fast_clip_32bit_to_pixel(((four_tap_filter_ver_avx2(c7, &src[src_pos - 1 * src_stride], src_stride) >> shift1) + (1 << (shift3 - 1))) >> shift3);
|
2014-11-20 16:38:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// When both flags, interpolate values from temporary horizontal values
|
|
|
|
if (hor_flag && ver_flag) {
|
|
|
|
|
|
|
|
// Calculate temporary values
|
|
|
|
src_pos -= 1 * src_stride; //0,-3
|
2015-02-05 11:28:07 +00:00
|
|
|
for (i = 0; i < 4; ++i) {
|
|
|
|
|
|
|
|
temp[0][i] = (four_tap_filter_hor_avx2(c1, &src[src_pos + i * src_stride - 1]) >> shift1);
|
|
|
|
temp[1][i] = (four_tap_filter_hor_avx2(c2, &src[src_pos + i * src_stride - 1]) >> shift1);
|
|
|
|
temp[2][i] = (four_tap_filter_hor_avx2(c3, &src[src_pos + i * src_stride - 1]) >> shift1);
|
|
|
|
temp[3][i] = (four_tap_filter_hor_avx2(c4, &src[src_pos + i * src_stride - 1]) >> shift1);
|
|
|
|
temp[4][i] = (four_tap_filter_hor_avx2(c5, &src[src_pos + i * src_stride - 1]) >> shift1);
|
|
|
|
temp[5][i] = (four_tap_filter_hor_avx2(c6, &src[src_pos + i * src_stride - 1]) >> shift1);
|
|
|
|
temp[6][i] = (four_tap_filter_hor_avx2(c7, &src[src_pos + i * src_stride - 1]) >> shift1);
|
|
|
|
|
2014-11-20 16:38:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//Calculate values from temporary horizontal 1/8-values
|
|
|
|
for (i = 0; i<7; ++i){
|
2015-02-05 11:28:07 +00:00
|
|
|
dst[dst_pos + 1 * dst_stride + i + 1] = fast_clip_32bit_to_pixel(((four_tap_filter_hor_16bit_avx2(c1, &temp[i][0]) + offset23) >> shift2) >> shift3); // ee0,0
|
|
|
|
dst[dst_pos + 2 * dst_stride + i + 1] = fast_clip_32bit_to_pixel(((four_tap_filter_hor_16bit_avx2(c2, &temp[i][0]) + offset23) >> shift2) >> shift3);
|
|
|
|
dst[dst_pos + 3 * dst_stride + i + 1] = fast_clip_32bit_to_pixel(((four_tap_filter_hor_16bit_avx2(c3, &temp[i][0]) + offset23) >> shift2) >> shift3);
|
|
|
|
dst[dst_pos + 4 * dst_stride + i + 1] = fast_clip_32bit_to_pixel(((four_tap_filter_hor_16bit_avx2(c4, &temp[i][0]) + offset23) >> shift2) >> shift3);
|
|
|
|
dst[dst_pos + 5 * dst_stride + i + 1] = fast_clip_32bit_to_pixel(((four_tap_filter_hor_16bit_avx2(c5, &temp[i][0]) + offset23) >> shift2) >> shift3);
|
|
|
|
dst[dst_pos + 6 * dst_stride + i + 1] = fast_clip_32bit_to_pixel(((four_tap_filter_hor_16bit_avx2(c6, &temp[i][0]) + offset23) >> shift2) >> shift3);
|
|
|
|
dst[dst_pos + 7 * dst_stride + i + 1] = fast_clip_32bit_to_pixel(((four_tap_filter_hor_16bit_avx2(c7, &temp[i][0]) + offset23) >> shift2) >> shift3);
|
2014-11-20 16:38:54 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
if (hor_flag) {
|
2015-02-05 11:28:07 +00:00
|
|
|
dst[dst_pos + 1] = fast_clip_32bit_to_pixel((temp[0][1] + offset3) >> shift3);
|
|
|
|
dst[dst_pos + 2] = fast_clip_32bit_to_pixel((temp[1][1] + offset3) >> shift3);
|
|
|
|
dst[dst_pos + 3] = fast_clip_32bit_to_pixel((temp[2][1] + offset3) >> shift3);
|
|
|
|
dst[dst_pos + 4] = fast_clip_32bit_to_pixel((temp[3][1] + offset3) >> shift3);
|
|
|
|
dst[dst_pos + 5] = fast_clip_32bit_to_pixel((temp[4][1] + offset3) >> shift3);
|
|
|
|
dst[dst_pos + 6] = fast_clip_32bit_to_pixel((temp[5][1] + offset3) >> shift3);
|
|
|
|
dst[dst_pos + 7] = fast_clip_32bit_to_pixel((temp[6][1] + offset3) >> shift3);
|
2014-11-20 16:38:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void extend_borders_avx2(int xpos, int ypos, int mv_x, int mv_y, int off_x, int off_y, pixel *ref, int ref_width, int ref_height,
|
2014-12-11 14:38:43 +00:00
|
|
|
int filterSize, int width, int height, pixel *dst) {
|
2014-11-20 16:38:54 +00:00
|
|
|
|
|
|
|
int16_t mv[2] = { mv_x, mv_y };
|
|
|
|
int halfFilterSize = filterSize >> 1;
|
|
|
|
|
|
|
|
int dst_y; int y; int dst_x; int x; int coord_x; int coord_y;
|
|
|
|
int8_t overflow_neg_y_temp, overflow_pos_y_temp, overflow_neg_x_temp, overflow_pos_x_temp;
|
|
|
|
|
|
|
|
for (dst_y = 0, y = ypos - halfFilterSize; y < ((ypos + height)) + halfFilterSize; dst_y++, y++) {
|
|
|
|
|
|
|
|
// calculate y-pixel offset
|
|
|
|
coord_y = y + off_y + mv[1];
|
|
|
|
|
|
|
|
// On y-overflow set coord_y accordingly
|
|
|
|
overflow_neg_y_temp = (coord_y < 0) ? 1 : 0;
|
|
|
|
overflow_pos_y_temp = (coord_y >= ref_height) ? 1 : 0;
|
|
|
|
if (overflow_neg_y_temp) coord_y = 0;
|
|
|
|
else if (overflow_pos_y_temp) coord_y = (ref_height)-1;
|
|
|
|
coord_y *= ref_width;
|
|
|
|
|
|
|
|
for (dst_x = 0, x = (xpos)-halfFilterSize; x < ((xpos + width)) + halfFilterSize; dst_x++, x++) {
|
|
|
|
coord_x = x + off_x + mv[0];
|
|
|
|
|
|
|
|
// On x-overflow set coord_x accordingly
|
|
|
|
overflow_neg_x_temp = (coord_x < 0) ? 1 : 0;
|
|
|
|
overflow_pos_x_temp = (coord_x >= ref_width) ? 1 : 0;
|
|
|
|
if (overflow_neg_x_temp) coord_x = 0;
|
|
|
|
else if (overflow_pos_x_temp) coord_x = ref_width - 1;
|
|
|
|
|
|
|
|
// Store source block data (with extended borders)
|
|
|
|
dst[dst_y*(width + filterSize) + dst_x] = ref[coord_y + coord_x];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int strategy_register_ipol_avx2(void* opaque)
|
|
|
|
{
|
|
|
|
bool success = true;
|
2015-02-05 11:28:07 +00:00
|
|
|
|
|
|
|
success &= strategyselector_register(opaque, "filter_inter_quarterpel_luma", "avx2", 0, &filter_inter_quarterpel_luma_avx2);
|
|
|
|
success &= strategyselector_register(opaque, "filter_inter_halfpel_chroma", "avx2", 0, &filter_inter_halfpel_chroma_avx2);
|
|
|
|
success &= strategyselector_register(opaque, "filter_inter_octpel_chroma", "avx2", 0, &filter_inter_octpel_chroma_avx2);
|
|
|
|
success &= strategyselector_register(opaque, "extend_borders", "avx2", 0, &extend_borders_avx2);
|
|
|
|
|
2014-11-20 16:38:54 +00:00
|
|
|
return success;
|
|
|
|
}
|