mozilla
/
aom
зеркало из
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Merge "Rename highbitdepth functions to use highbd prefix"

This commit is contained in:
Deb Mukherjee 2014-10-09 15:39:56 -07:00 коммит произвёл Gerrit Code Review
Родитель 112789d4f2 1929c9b391
Коммит 9a29fdbae7
40 изменённых файлов: 2633 добавлений и 2539 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

300
test/convolve_test.cc
Просмотреть файл

@ -36,7 +36,7 @@ struct ConvolveFunctions {
ConvolveFunc hv8, ConvolveFunc hv8_avg,
int bd)
: h8_(h8), v8_(v8), hv8_(hv8), h8_avg_(h8_avg), v8_avg_(v8_avg),
hv8_avg_(hv8_avg), use_high_bd_(bd) {}
hv8_avg_(hv8_avg), use_highbd_(bd) {}
ConvolveFunc h8_;
ConvolveFunc v8_;
@ -44,7 +44,7 @@ struct ConvolveFunctions {
ConvolveFunc h8_avg_;
ConvolveFunc v8_avg_;
ConvolveFunc hv8_avg_;
int use_high_bd_; // 0 if high bitdepth not used, else the actual bit depth.
int use_highbd_; // 0 if high bitdepth not used, else the actual bit depth.
};
typedef std::tr1::tuple<int, int, const ConvolveFunctions *> ConvolveParam;
@ -170,15 +170,15 @@ void filter_average_block2d_8_c(const uint8_t *src_ptr,
}
#if CONFIG_VP9_HIGHBITDEPTH
void high_filter_block2d_8_c(const uint16_t *src_ptr,
const unsigned int src_stride,
const int16_t *HFilter,
const int16_t *VFilter,
uint16_t *dst_ptr,
unsigned int dst_stride,
unsigned int output_width,
unsigned int output_height,
int bd) {
void highbd_filter_block2d_8_c(const uint16_t *src_ptr,
const unsigned int src_stride,
const int16_t *HFilter,
const int16_t *VFilter,
uint16_t *dst_ptr,
unsigned int dst_stride,
unsigned int output_width,
unsigned int output_height,
int bd) {
// Between passes, we use an intermediate buffer whose height is extended to
// have enough horizontally filtered values as input for the vertical pass.
// This buffer is allocated to be big enough for the largest block type we
@ -254,13 +254,13 @@ void high_filter_block2d_8_c(const uint16_t *src_ptr,
}
}
void high_block2d_average_c(uint16_t *src,
unsigned int src_stride,
uint16_t *output_ptr,
unsigned int output_stride,
unsigned int output_width,
unsigned int output_height,
int bd) {
void highbd_block2d_average_c(uint16_t *src,
unsigned int src_stride,
uint16_t *output_ptr,
unsigned int output_stride,
unsigned int output_width,
unsigned int output_height,
int bd) {
unsigned int i, j;
for (i = 0; i < output_height; ++i) {
for (j = 0; j < output_width; ++j) {
@ -270,23 +270,23 @@ void high_block2d_average_c(uint16_t *src,
}
}
void high_filter_average_block2d_8_c(const uint16_t *src_ptr,
const unsigned int src_stride,
const int16_t *HFilter,
const int16_t *VFilter,
uint16_t *dst_ptr,
unsigned int dst_stride,
unsigned int output_width,
unsigned int output_height,
int bd) {
void highbd_filter_average_block2d_8_c(const uint16_t *src_ptr,
const unsigned int src_stride,
const int16_t *HFilter,
const int16_t *VFilter,
uint16_t *dst_ptr,
unsigned int dst_stride,
unsigned int output_width,
unsigned int output_height,
int bd) {
uint16_t tmp[kMaxDimension * kMaxDimension];
assert(output_width <= kMaxDimension);
assert(output_height <= kMaxDimension);
high_filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, tmp, 64,
output_width, output_height, bd);
high_block2d_average_c(tmp, 64, dst_ptr, dst_stride,
output_width, output_height, bd);
highbd_filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter, tmp, 64,
output_width, output_height, bd);
highbd_block2d_average_c(tmp, 64, dst_ptr, dst_stride,
output_width, output_height, bd);
}
#endif // CONFIG_VP9_HIGHBITDEPTH
@ -346,8 +346,8 @@ class ConvolveTest : public ::testing::TestWithParam<ConvolveParam> {
virtual void SetUp() {
UUT_ = GET_PARAM(2);
#if CONFIG_VP9_HIGHBITDEPTH
if (UUT_->use_high_bd_ != 0)
mask_ = (1 << UUT_->use_high_bd_) - 1;
if (UUT_->use_highbd_ != 0)
mask_ = (1 << UUT_->use_highbd_) - 1;
else
mask_ = 255;
#endif
@ -391,7 +391,7 @@ class ConvolveTest : public ::testing::TestWithParam<ConvolveParam> {
uint8_t *input() const {
#if CONFIG_VP9_HIGHBITDEPTH
if (UUT_->use_high_bd_ == 0) {
if (UUT_->use_highbd_ == 0) {
return input_ + BorderTop() * kOuterBlockSize + BorderLeft();
} else {
return CONVERT_TO_BYTEPTR(input16_ + BorderTop() * kOuterBlockSize +
@ -404,7 +404,7 @@ class ConvolveTest : public ::testing::TestWithParam<ConvolveParam> {
uint8_t *output() const {
#if CONFIG_VP9_HIGHBITDEPTH
if (UUT_->use_high_bd_ == 0) {
if (UUT_->use_highbd_ == 0) {
return output_ + BorderTop() * kOuterBlockSize + BorderLeft();
} else {
return CONVERT_TO_BYTEPTR(output16_ + BorderTop() * kOuterBlockSize +
@ -417,7 +417,7 @@ class ConvolveTest : public ::testing::TestWithParam<ConvolveParam> {
uint16_t lookup(uint8_t *list, int index) const {
#if CONFIG_VP9_HIGHBITDEPTH
if (UUT_->use_high_bd_ == 0) {
if (UUT_->use_highbd_ == 0) {
return list[index];
} else {
return CONVERT_TO_SHORTPTR(list)[index];
@ -429,7 +429,7 @@ class ConvolveTest : public ::testing::TestWithParam<ConvolveParam> {
void assign_val(uint8_t *list, int index, uint16_t val) const {
#if CONFIG_VP9_HIGHBITDEPTH
if (UUT_->use_high_bd_ == 0) {
if (UUT_->use_highbd_ == 0) {
list[index] = (uint8_t) val;
} else {
CONVERT_TO_SHORTPTR(list)[index] = val;
@ -448,16 +448,16 @@ class ConvolveTest : public ::testing::TestWithParam<ConvolveParam> {
unsigned int output_width,
unsigned int output_height) {
#if CONFIG_VP9_HIGHBITDEPTH
if (UUT_->use_high_bd_ == 0) {
if (UUT_->use_highbd_ == 0) {
filter_average_block2d_8_c(src_ptr, src_stride, HFilter, VFilter,
dst_ptr, dst_stride, output_width,
output_height);
} else {
high_filter_average_block2d_8_c(CONVERT_TO_SHORTPTR(src_ptr), src_stride,
HFilter, VFilter,
CONVERT_TO_SHORTPTR(dst_ptr), dst_stride,
output_width, output_height,
UUT_->use_high_bd_);
highbd_filter_average_block2d_8_c(CONVERT_TO_SHORTPTR(src_ptr),
src_stride, HFilter, VFilter,
CONVERT_TO_SHORTPTR(dst_ptr),
dst_stride, output_width, output_height,
UUT_->use_highbd_);
}
#else
filter_average_block2d_8_c(src_ptr, src_stride, HFilter, VFilter,
@ -475,14 +475,14 @@ class ConvolveTest : public ::testing::TestWithParam<ConvolveParam> {
unsigned int output_width,
unsigned int output_height) {
#if CONFIG_VP9_HIGHBITDEPTH
if (UUT_->use_high_bd_ == 0) {
if (UUT_->use_highbd_ == 0) {
filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter,
dst_ptr, dst_stride, output_width, output_height);
} else {
high_filter_block2d_8_c(CONVERT_TO_SHORTPTR(src_ptr), src_stride,
HFilter, VFilter,
CONVERT_TO_SHORTPTR(dst_ptr), dst_stride,
output_width, output_height, UUT_->use_high_bd_);
highbd_filter_block2d_8_c(CONVERT_TO_SHORTPTR(src_ptr), src_stride,
HFilter, VFilter,
CONVERT_TO_SHORTPTR(dst_ptr), dst_stride,
output_width, output_height, UUT_->use_highbd_);
}
#else
filter_block2d_8_c(src_ptr, src_stride, HFilter, VFilter,
@ -598,7 +598,7 @@ TEST_P(ConvolveTest, MatchesReferenceSubpixelFilter) {
uint8_t ref8[kOutputStride * kMaxDimension];
uint16_t ref16[kOutputStride * kMaxDimension];
uint8_t* ref;
if (UUT_->use_high_bd_ == 0) {
if (UUT_->use_highbd_ == 0) {
ref = ref8;
} else {
ref = CONVERT_TO_BYTEPTR(ref16);
@ -657,7 +657,7 @@ TEST_P(ConvolveTest, MatchesReferenceAveragingSubpixelFilter) {
uint8_t ref8[kOutputStride * kMaxDimension];
uint16_t ref16[kOutputStride * kMaxDimension];
uint8_t* ref;
if (UUT_->use_high_bd_ == 0) {
if (UUT_->use_highbd_ == 0) {
ref = ref8;
} else {
ref = CONVERT_TO_BYTEPTR(ref16);
@ -672,7 +672,7 @@ TEST_P(ConvolveTest, MatchesReferenceAveragingSubpixelFilter) {
for (int x = 0; x < Width(); ++x) {
uint16_t r;
#if CONFIG_VP9_HIGHBITDEPTH
if (UUT_->use_high_bd_ == 0 || UUT_->use_high_bd_ == 8) {
if (UUT_->use_highbd_ == 0 || UUT_->use_highbd_ == 8) {
r = prng.Rand8Extremes();
} else {
r = prng.Rand16() & mask_;
@ -736,7 +736,7 @@ TEST_P(ConvolveTest, FilterExtremes) {
uint8_t ref8[kOutputStride * kMaxDimension];
uint16_t ref16[kOutputStride * kMaxDimension];
uint8_t *ref;
if (UUT_->use_high_bd_ == 0) {
if (UUT_->use_highbd_ == 0) {
ref = ref8;
} else {
ref = CONVERT_TO_BYTEPTR(ref16);
@ -751,7 +751,7 @@ TEST_P(ConvolveTest, FilterExtremes) {
for (int x = 0; x < Width(); ++x) {
uint16_t r;
#if CONFIG_VP9_HIGHBITDEPTH
if (UUT_->use_high_bd_ == 0 || UUT_->use_high_bd_ == 8) {
if (UUT_->use_highbd_ == 0 || UUT_->use_highbd_ == 8) {
r = prng.Rand8Extremes();
} else {
r = prng.Rand16() & mask_;
@ -978,9 +978,9 @@ void wrap_convolve8_horiz_sse2_8(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_horiz_sse2(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride,
w, h, 8);
vp9_highbd_convolve8_horiz_sse2(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride,
w, h, 8);
}
void wrap_convolve8_avg_horiz_sse2_8(const uint8_t *src, ptrdiff_t src_stride,
@ -990,8 +990,9 @@ void wrap_convolve8_avg_horiz_sse2_8(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_avg_horiz_sse2(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 8);
vp9_highbd_convolve8_avg_horiz_sse2(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 8);
}
void wrap_convolve8_vert_sse2_8(const uint8_t *src, ptrdiff_t src_stride,
@ -1001,8 +1002,9 @@ void wrap_convolve8_vert_sse2_8(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_vert_sse2(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 8);
vp9_highbd_convolve8_vert_sse2(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 8);
}
void wrap_convolve8_avg_vert_sse2_8(const uint8_t *src, ptrdiff_t src_stride,
@ -1012,9 +1014,9 @@ void wrap_convolve8_avg_vert_sse2_8(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_avg_vert_sse2(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride,
w, h, 8);
vp9_highbd_convolve8_avg_vert_sse2(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 8);
}
void wrap_convolve8_sse2_8(const uint8_t *src, ptrdiff_t src_stride,
@ -1024,8 +1026,9 @@ void wrap_convolve8_sse2_8(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_sse2(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 8);
vp9_highbd_convolve8_sse2(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 8);
}
void wrap_convolve8_avg_sse2_8(const uint8_t *src, ptrdiff_t src_stride,
@ -1035,8 +1038,9 @@ void wrap_convolve8_avg_sse2_8(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_avg_sse2(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 8);
vp9_highbd_convolve8_avg_sse2(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 8);
}
void wrap_convolve8_horiz_sse2_10(const uint8_t *src, ptrdiff_t src_stride,
@ -1046,8 +1050,9 @@ void wrap_convolve8_horiz_sse2_10(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_horiz_sse2(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 10);
vp9_highbd_convolve8_horiz_sse2(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 10);
}
void wrap_convolve8_avg_horiz_sse2_10(const uint8_t *src, ptrdiff_t src_stride,
@ -1057,8 +1062,9 @@ void wrap_convolve8_avg_horiz_sse2_10(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_avg_horiz_sse2(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 10);
vp9_highbd_convolve8_avg_horiz_sse2(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 10);
}
void wrap_convolve8_vert_sse2_10(const uint8_t *src, ptrdiff_t src_stride,
@ -1068,8 +1074,9 @@ void wrap_convolve8_vert_sse2_10(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_vert_sse2(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 10);
vp9_highbd_convolve8_vert_sse2(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 10);
}
void wrap_convolve8_avg_vert_sse2_10(const uint8_t *src, ptrdiff_t src_stride,
@ -1079,8 +1086,9 @@ void wrap_convolve8_avg_vert_sse2_10(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_avg_vert_sse2(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 10);
vp9_highbd_convolve8_avg_vert_sse2(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 10);
}
void wrap_convolve8_sse2_10(const uint8_t *src, ptrdiff_t src_stride,
@ -1090,8 +1098,9 @@ void wrap_convolve8_sse2_10(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_sse2(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 10);
vp9_highbd_convolve8_sse2(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 10);
}
void wrap_convolve8_avg_sse2_10(const uint8_t *src, ptrdiff_t src_stride,
@ -1101,9 +1110,9 @@ void wrap_convolve8_avg_sse2_10(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_avg_sse2(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride,
w, h, 10);
vp9_highbd_convolve8_avg_sse2(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 10);
}
void wrap_convolve8_horiz_sse2_12(const uint8_t *src, ptrdiff_t src_stride,
@ -1113,9 +1122,9 @@ void wrap_convolve8_horiz_sse2_12(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_horiz_sse2(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride,
w, h, 12);
vp9_highbd_convolve8_horiz_sse2(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 12);
}
void wrap_convolve8_avg_horiz_sse2_12(const uint8_t *src, ptrdiff_t src_stride,
@ -1125,9 +1134,9 @@ void wrap_convolve8_avg_horiz_sse2_12(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_avg_horiz_sse2(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride,
w, h, 12);
vp9_highbd_convolve8_avg_horiz_sse2(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 12);
}
void wrap_convolve8_vert_sse2_12(const uint8_t *src, ptrdiff_t src_stride,
@ -1137,9 +1146,9 @@ void wrap_convolve8_vert_sse2_12(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_vert_sse2(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride,
w, h, 12);
vp9_highbd_convolve8_vert_sse2(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 12);
}
void wrap_convolve8_avg_vert_sse2_12(const uint8_t *src, ptrdiff_t src_stride,
@ -1149,8 +1158,9 @@ void wrap_convolve8_avg_vert_sse2_12(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_avg_vert_sse2(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 12);
vp9_highbd_convolve8_avg_vert_sse2(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 12);
}
void wrap_convolve8_sse2_12(const uint8_t *src, ptrdiff_t src_stride,
@ -1160,8 +1170,9 @@ void wrap_convolve8_sse2_12(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_sse2(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 12);
vp9_highbd_convolve8_sse2(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 12);
}
void wrap_convolve8_avg_sse2_12(const uint8_t *src, ptrdiff_t src_stride,
@ -1171,8 +1182,9 @@ void wrap_convolve8_avg_sse2_12(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_avg_sse2(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 12);
vp9_highbd_convolve8_avg_sse2(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 12);
}
#endif // HAVE_SSE2 && ARCH_X86_64
@ -1183,8 +1195,9 @@ void wrap_convolve8_horiz_c_8(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_horiz_c(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 8);
vp9_highbd_convolve8_horiz_c(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 8);
}
void wrap_convolve8_avg_horiz_c_8(const uint8_t *src, ptrdiff_t src_stride,
@ -1194,8 +1207,9 @@ void wrap_convolve8_avg_horiz_c_8(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_avg_horiz_c(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 8);
vp9_highbd_convolve8_avg_horiz_c(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 8);
}
void wrap_convolve8_vert_c_8(const uint8_t *src, ptrdiff_t src_stride,
@ -1205,8 +1219,9 @@ void wrap_convolve8_vert_c_8(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_vert_c(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 8);
vp9_highbd_convolve8_vert_c(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 8);
}
void wrap_convolve8_avg_vert_c_8(const uint8_t *src, ptrdiff_t src_stride,
@ -1216,8 +1231,9 @@ void wrap_convolve8_avg_vert_c_8(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_avg_vert_c(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 8);
vp9_highbd_convolve8_avg_vert_c(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 8);
}
void wrap_convolve8_c_8(const uint8_t *src, ptrdiff_t src_stride,
@ -1227,8 +1243,9 @@ void wrap_convolve8_c_8(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_c(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 8);
vp9_highbd_convolve8_c(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 8);
}
void wrap_convolve8_avg_c_8(const uint8_t *src, ptrdiff_t src_stride,
@ -1238,9 +1255,9 @@ void wrap_convolve8_avg_c_8(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_avg_c(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride,
w, h, 8);
vp9_highbd_convolve8_avg_c(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 8);
}
void wrap_convolve8_horiz_c_10(const uint8_t *src, ptrdiff_t src_stride,
@ -1250,8 +1267,9 @@ void wrap_convolve8_horiz_c_10(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_horiz_c(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 10);
vp9_highbd_convolve8_horiz_c(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 10);
}
void wrap_convolve8_avg_horiz_c_10(const uint8_t *src, ptrdiff_t src_stride,
@ -1261,9 +1279,9 @@ void wrap_convolve8_avg_horiz_c_10(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_avg_horiz_c(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride,
w, h, 10);
vp9_highbd_convolve8_avg_horiz_c(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 10);
}
void wrap_convolve8_vert_c_10(const uint8_t *src, ptrdiff_t src_stride,
@ -1273,8 +1291,9 @@ void wrap_convolve8_vert_c_10(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_vert_c(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 10);
vp9_highbd_convolve8_vert_c(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 10);
}
void wrap_convolve8_avg_vert_c_10(const uint8_t *src, ptrdiff_t src_stride,
@ -1284,8 +1303,9 @@ void wrap_convolve8_avg_vert_c_10(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_avg_vert_c(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 10);
vp9_highbd_convolve8_avg_vert_c(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 10);
}
void wrap_convolve8_c_10(const uint8_t *src, ptrdiff_t src_stride,
@ -1295,8 +1315,9 @@ void wrap_convolve8_c_10(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_c(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 10);
vp9_highbd_convolve8_c(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 10);
}
void wrap_convolve8_avg_c_10(const uint8_t *src, ptrdiff_t src_stride,
@ -1306,8 +1327,9 @@ void wrap_convolve8_avg_c_10(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_avg_c(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride, w, h, 10);
vp9_highbd_convolve8_avg_c(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 10);
}
void wrap_convolve8_horiz_c_12(const uint8_t *src, ptrdiff_t src_stride,
@ -1317,9 +1339,9 @@ void wrap_convolve8_horiz_c_12(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_horiz_c(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride,
w, h, 12);
vp9_highbd_convolve8_horiz_c(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 12);
}
void wrap_convolve8_avg_horiz_c_12(const uint8_t *src, ptrdiff_t src_stride,
@ -1329,9 +1351,9 @@ void wrap_convolve8_avg_horiz_c_12(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_avg_horiz_c(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride,
w, h, 12);
vp9_highbd_convolve8_avg_horiz_c(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 12);
}
void wrap_convolve8_vert_c_12(const uint8_t *src, ptrdiff_t src_stride,
@ -1341,9 +1363,9 @@ void wrap_convolve8_vert_c_12(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_vert_c(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride,
w, h, 12);
vp9_highbd_convolve8_vert_c(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 12);
}
void wrap_convolve8_avg_vert_c_12(const uint8_t *src, ptrdiff_t src_stride,
@ -1353,9 +1375,9 @@ void wrap_convolve8_avg_vert_c_12(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_avg_vert_c(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride,
w, h, 12);
vp9_highbd_convolve8_avg_vert_c(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 12);
}
void wrap_convolve8_c_12(const uint8_t *src, ptrdiff_t src_stride,
@ -1365,9 +1387,9 @@ void wrap_convolve8_c_12(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_c(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride,
w, h, 12);
vp9_highbd_convolve8_c(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 12);
}
void wrap_convolve8_avg_c_12(const uint8_t *src, ptrdiff_t src_stride,
@ -1377,9 +1399,9 @@ void wrap_convolve8_avg_c_12(const uint8_t *src, ptrdiff_t src_stride,
const int16_t *filter_y,
int filter_y_stride,
int w, int h) {
vp9_high_convolve8_avg_c(src, src_stride, dst, dst_stride, filter_x,
filter_x_stride, filter_y, filter_y_stride,
w, h, 12);
vp9_highbd_convolve8_avg_c(src, src_stride, dst, dst_stride,
filter_x, filter_x_stride,
filter_y, filter_y_stride, w, h, 12);
}
const ConvolveFunctions convolve8_c(

28
test/dct16x16_test.cc
Просмотреть файл

@ -287,11 +287,11 @@ void iht16x16_ref(const tran_low_t *in, uint8_t *dest, int stride,
#if CONFIG_VP9_HIGHBITDEPTH
void idct16x16_10(const tran_low_t *in, uint8_t *out, int stride) {
vp9_high_idct16x16_256_add_c(in, out, stride, 10);
vp9_highbd_idct16x16_256_add_c(in, out, stride, 10);
}
void idct16x16_12(const tran_low_t *in, uint8_t *out, int stride) {
vp9_high_idct16x16_256_add_c(in, out, stride, 12);
vp9_highbd_idct16x16_256_add_c(in, out, stride, 12);
}
void idct16x16_10_ref(const tran_low_t *in, uint8_t *out, int stride,
@ -305,11 +305,11 @@ void idct16x16_12_ref(const tran_low_t *in, uint8_t *out, int stride,
}
void iht16x16_10(const tran_low_t *in, uint8_t *out, int stride, int tx_type) {
vp9_high_iht16x16_256_add_c(in, out, stride, tx_type, 10);
vp9_highbd_iht16x16_256_add_c(in, out, stride, tx_type, 10);
}
void iht16x16_12(const tran_low_t *in, uint8_t *out, int stride, int tx_type) {
vp9_high_iht16x16_256_add_c(in, out, stride, tx_type, 12);
vp9_highbd_iht16x16_256_add_c(in, out, stride, tx_type, 12);
}
#endif
@ -709,8 +709,8 @@ using std::tr1::make_tuple;
INSTANTIATE_TEST_CASE_P(
C, Trans16x16DCT,
::testing::Values(
make_tuple(&vp9_high_fdct16x16_c, &idct16x16_10, 0, VPX_BITS_10),
make_tuple(&vp9_high_fdct16x16_c, &idct16x16_12, 0, VPX_BITS_12),
make_tuple(&vp9_highbd_fdct16x16_c, &idct16x16_10, 0, VPX_BITS_10),
make_tuple(&vp9_highbd_fdct16x16_c, &idct16x16_12, 0, VPX_BITS_12),
make_tuple(&vp9_fdct16x16_c, &vp9_idct16x16_256_add_c, 0, VPX_BITS_8)));
#else
INSTANTIATE_TEST_CASE_P(
@ -723,14 +723,14 @@ INSTANTIATE_TEST_CASE_P(
INSTANTIATE_TEST_CASE_P(
C, Trans16x16HT,
::testing::Values(
make_tuple(&vp9_high_fht16x16_c, &iht16x16_10, 0, VPX_BITS_10),
make_tuple(&vp9_high_fht16x16_c, &iht16x16_10, 1, VPX_BITS_10),
make_tuple(&vp9_high_fht16x16_c, &iht16x16_10, 2, VPX_BITS_10),
make_tuple(&vp9_high_fht16x16_c, &iht16x16_10, 3, VPX_BITS_10),
make_tuple(&vp9_high_fht16x16_c, &iht16x16_12, 0, VPX_BITS_12),
make_tuple(&vp9_high_fht16x16_c, &iht16x16_12, 1, VPX_BITS_12),
make_tuple(&vp9_high_fht16x16_c, &iht16x16_12, 2, VPX_BITS_12),
make_tuple(&vp9_high_fht16x16_c, &iht16x16_12, 3, VPX_BITS_12),
make_tuple(&vp9_highbd_fht16x16_c, &iht16x16_10, 0, VPX_BITS_10),
make_tuple(&vp9_highbd_fht16x16_c, &iht16x16_10, 1, VPX_BITS_10),
make_tuple(&vp9_highbd_fht16x16_c, &iht16x16_10, 2, VPX_BITS_10),
make_tuple(&vp9_highbd_fht16x16_c, &iht16x16_10, 3, VPX_BITS_10),
make_tuple(&vp9_highbd_fht16x16_c, &iht16x16_12, 0, VPX_BITS_12),
make_tuple(&vp9_highbd_fht16x16_c, &iht16x16_12, 1, VPX_BITS_12),
make_tuple(&vp9_highbd_fht16x16_c, &iht16x16_12, 2, VPX_BITS_12),
make_tuple(&vp9_highbd_fht16x16_c, &iht16x16_12, 3, VPX_BITS_12),
make_tuple(&vp9_fht16x16_c, &vp9_iht16x16_256_add_c, 0, VPX_BITS_8),
make_tuple(&vp9_fht16x16_c, &vp9_iht16x16_256_add_c, 1, VPX_BITS_8),
make_tuple(&vp9_fht16x16_c, &vp9_iht16x16_256_add_c, 2, VPX_BITS_8),

12
test/dct32x32_test.cc
Просмотреть файл

@ -80,11 +80,11 @@ typedef std::tr1::tuple<FwdTxfmFunc, InvTxfmFunc, int, vpx_bit_depth_t>
#if CONFIG_VP9_HIGHBITDEPTH
void idct32x32_10(const tran_low_t *in, uint8_t *out, int stride) {
vp9_high_idct32x32_1024_add_c(in, out, stride, 10);
vp9_highbd_idct32x32_1024_add_c(in, out, stride, 10);
}
void idct32x32_12(const tran_low_t *in, uint8_t *out, int stride) {
vp9_high_idct32x32_1024_add_c(in, out, stride, 12);
vp9_highbd_idct32x32_1024_add_c(in, out, stride, 12);
}
#endif
@ -311,13 +311,13 @@ using std::tr1::make_tuple;
INSTANTIATE_TEST_CASE_P(
C, Trans32x32Test,
::testing::Values(
make_tuple(&vp9_high_fdct32x32_c,
make_tuple(&vp9_highbd_fdct32x32_c,
&idct32x32_10, 0, VPX_BITS_10),
make_tuple(&vp9_high_fdct32x32_rd_c,
make_tuple(&vp9_highbd_fdct32x32_rd_c,
&idct32x32_10, 1, VPX_BITS_10),
make_tuple(&vp9_high_fdct32x32_c,
make_tuple(&vp9_highbd_fdct32x32_c,
&idct32x32_12, 0, VPX_BITS_12),
make_tuple(&vp9_high_fdct32x32_rd_c,
make_tuple(&vp9_highbd_fdct32x32_rd_c,
&idct32x32_12, 1, VPX_BITS_12),
make_tuple(&vp9_fdct32x32_c,
&vp9_idct32x32_1024_add_c, 0, VPX_BITS_8),

36
test/fdct4x4_test.cc
Просмотреть файл

@ -53,27 +53,27 @@ void fwht4x4_ref(const int16_t *in, tran_low_t *out, int stride,
#if CONFIG_VP9_HIGHBITDEPTH
void idct4x4_10(const tran_low_t *in, uint8_t *out, int stride) {
vp9_high_idct4x4_16_add_c(in, out, stride, 10);
vp9_highbd_idct4x4_16_add_c(in, out, stride, 10);
}
void idct4x4_12(const tran_low_t *in, uint8_t *out, int stride) {
vp9_high_idct4x4_16_add_c(in, out, stride, 12);
vp9_highbd_idct4x4_16_add_c(in, out, stride, 12);
}
void iht4x4_10(const tran_low_t *in, uint8_t *out, int stride, int tx_type) {
vp9_high_iht4x4_16_add_c(in, out, stride, tx_type, 10);
vp9_highbd_iht4x4_16_add_c(in, out, stride, tx_type, 10);
}
void iht4x4_12(const tran_low_t *in, uint8_t *out, int stride, int tx_type) {
vp9_high_iht4x4_16_add_c(in, out, stride, tx_type, 12);
vp9_highbd_iht4x4_16_add_c(in, out, stride, tx_type, 12);
}
void iwht4x4_10(const tran_low_t *in, uint8_t *out, int stride) {
vp9_high_iwht4x4_16_add_c(in, out, stride, 10);
vp9_highbd_iwht4x4_16_add_c(in, out, stride, 10);
}
void iwht4x4_12(const tran_low_t *in, uint8_t *out, int stride) {
vp9_high_iwht4x4_16_add_c(in, out, stride, 12);
vp9_highbd_iwht4x4_16_add_c(in, out, stride, 12);
}
#endif
@ -408,8 +408,8 @@ using std::tr1::make_tuple;
INSTANTIATE_TEST_CASE_P(
C, Trans4x4DCT,
::testing::Values(
make_tuple(&vp9_high_fdct4x4_c, &idct4x4_10, 0, VPX_BITS_10),
make_tuple(&vp9_high_fdct4x4_c, &idct4x4_12, 0, VPX_BITS_12),
make_tuple(&vp9_highbd_fdct4x4_c, &idct4x4_10, 0, VPX_BITS_10),
make_tuple(&vp9_highbd_fdct4x4_c, &idct4x4_12, 0, VPX_BITS_12),
make_tuple(&vp9_fdct4x4_c, &vp9_idct4x4_16_add_c, 0, VPX_BITS_8)));
#else
INSTANTIATE_TEST_CASE_P(
@ -422,14 +422,14 @@ INSTANTIATE_TEST_CASE_P(
INSTANTIATE_TEST_CASE_P(
C, Trans4x4HT,
::testing::Values(
make_tuple(&vp9_high_fht4x4_c, &iht4x4_10, 0, VPX_BITS_10),
make_tuple(&vp9_high_fht4x4_c, &iht4x4_10, 1, VPX_BITS_10),
make_tuple(&vp9_high_fht4x4_c, &iht4x4_10, 2, VPX_BITS_10),
make_tuple(&vp9_high_fht4x4_c, &iht4x4_10, 3, VPX_BITS_10),
make_tuple(&vp9_high_fht4x4_c, &iht4x4_12, 0, VPX_BITS_12),
make_tuple(&vp9_high_fht4x4_c, &iht4x4_12, 1, VPX_BITS_12),
make_tuple(&vp9_high_fht4x4_c, &iht4x4_12, 2, VPX_BITS_12),
make_tuple(&vp9_high_fht4x4_c, &iht4x4_12, 3, VPX_BITS_12),
make_tuple(&vp9_highbd_fht4x4_c, &iht4x4_10, 0, VPX_BITS_10),
make_tuple(&vp9_highbd_fht4x4_c, &iht4x4_10, 1, VPX_BITS_10),
make_tuple(&vp9_highbd_fht4x4_c, &iht4x4_10, 2, VPX_BITS_10),
make_tuple(&vp9_highbd_fht4x4_c, &iht4x4_10, 3, VPX_BITS_10),
make_tuple(&vp9_highbd_fht4x4_c, &iht4x4_12, 0, VPX_BITS_12),
make_tuple(&vp9_highbd_fht4x4_c, &iht4x4_12, 1, VPX_BITS_12),
make_tuple(&vp9_highbd_fht4x4_c, &iht4x4_12, 2, VPX_BITS_12),
make_tuple(&vp9_highbd_fht4x4_c, &iht4x4_12, 3, VPX_BITS_12),
make_tuple(&vp9_fht4x4_c, &vp9_iht4x4_16_add_c, 0, VPX_BITS_8),
make_tuple(&vp9_fht4x4_c, &vp9_iht4x4_16_add_c, 1, VPX_BITS_8),
make_tuple(&vp9_fht4x4_c, &vp9_iht4x4_16_add_c, 2, VPX_BITS_8),
@ -448,8 +448,8 @@ INSTANTIATE_TEST_CASE_P(
INSTANTIATE_TEST_CASE_P(
C, Trans4x4WHT,
::testing::Values(
make_tuple(&vp9_high_fwht4x4_c, &iwht4x4_10, 0, VPX_BITS_10),
make_tuple(&vp9_high_fwht4x4_c, &iwht4x4_12, 0, VPX_BITS_12),
make_tuple(&vp9_highbd_fwht4x4_c, &iwht4x4_10, 0, VPX_BITS_10),
make_tuple(&vp9_highbd_fwht4x4_c, &iwht4x4_12, 0, VPX_BITS_12),
make_tuple(&vp9_fwht4x4_c, &vp9_iwht4x4_16_add_c, 0, VPX_BITS_8)));
#else
INSTANTIATE_TEST_CASE_P(

28
test/fdct8x8_test.cc
Просмотреть файл

@ -82,19 +82,19 @@ void fht8x8_ref(const int16_t *in, tran_low_t *out, int stride, int tx_type) {
#if CONFIG_VP9_HIGHBITDEPTH
void idct8x8_10(const tran_low_t *in, uint8_t *out, int stride) {
vp9_high_idct8x8_64_add_c(in, out, stride, 10);
vp9_highbd_idct8x8_64_add_c(in, out, stride, 10);
}
void idct8x8_12(const tran_low_t *in, uint8_t *out, int stride) {
vp9_high_idct8x8_64_add_c(in, out, stride, 12);
vp9_highbd_idct8x8_64_add_c(in, out, stride, 12);
}
void iht8x8_10(const tran_low_t *in, uint8_t *out, int stride, int tx_type) {
vp9_high_iht8x8_64_add_c(in, out, stride, tx_type, 10);
vp9_highbd_iht8x8_64_add_c(in, out, stride, tx_type, 10);
}
void iht8x8_12(const tran_low_t *in, uint8_t *out, int stride, int tx_type) {
vp9_high_iht8x8_64_add_c(in, out, stride, tx_type, 12);
vp9_highbd_iht8x8_64_add_c(in, out, stride, tx_type, 12);
}
#endif
@ -532,8 +532,8 @@ using std::tr1::make_tuple;
INSTANTIATE_TEST_CASE_P(
C, FwdTrans8x8DCT,
::testing::Values(
make_tuple(&vp9_high_fdct8x8_c, &idct8x8_10, 0, VPX_BITS_10),
make_tuple(&vp9_high_fdct8x8_c, &idct8x8_12, 0, VPX_BITS_12),
make_tuple(&vp9_highbd_fdct8x8_c, &idct8x8_10, 0, VPX_BITS_10),
make_tuple(&vp9_highbd_fdct8x8_c, &idct8x8_12, 0, VPX_BITS_12),
make_tuple(&vp9_fdct8x8_c, &vp9_idct8x8_64_add_c, 0, VPX_BITS_8)));
#else
INSTANTIATE_TEST_CASE_P(
@ -546,14 +546,14 @@ INSTANTIATE_TEST_CASE_P(
INSTANTIATE_TEST_CASE_P(
C, FwdTrans8x8HT,
::testing::Values(
make_tuple(&vp9_high_fht8x8_c, &iht8x8_10, 0, VPX_BITS_10),
make_tuple(&vp9_high_fht8x8_c, &iht8x8_10, 1, VPX_BITS_10),
make_tuple(&vp9_high_fht8x8_c, &iht8x8_10, 2, VPX_BITS_10),
make_tuple(&vp9_high_fht8x8_c, &iht8x8_10, 3, VPX_BITS_10),
make_tuple(&vp9_high_fht8x8_c, &iht8x8_12, 0, VPX_BITS_12),
make_tuple(&vp9_high_fht8x8_c, &iht8x8_12, 1, VPX_BITS_12),
make_tuple(&vp9_high_fht8x8_c, &iht8x8_12, 2, VPX_BITS_12),
make_tuple(&vp9_high_fht8x8_c, &iht8x8_12, 3, VPX_BITS_12),
make_tuple(&vp9_highbd_fht8x8_c, &iht8x8_10, 0, VPX_BITS_10),
make_tuple(&vp9_highbd_fht8x8_c, &iht8x8_10, 1, VPX_BITS_10),
make_tuple(&vp9_highbd_fht8x8_c, &iht8x8_10, 2, VPX_BITS_10),
make_tuple(&vp9_highbd_fht8x8_c, &iht8x8_10, 3, VPX_BITS_10),
make_tuple(&vp9_highbd_fht8x8_c, &iht8x8_12, 0, VPX_BITS_12),
make_tuple(&vp9_highbd_fht8x8_c, &iht8x8_12, 1, VPX_BITS_12),
make_tuple(&vp9_highbd_fht8x8_c, &iht8x8_12, 2, VPX_BITS_12),
make_tuple(&vp9_highbd_fht8x8_c, &iht8x8_12, 3, VPX_BITS_12),
make_tuple(&vp9_fht8x8_c, &vp9_iht8x8_64_add_c, 0, VPX_BITS_8),
make_tuple(&vp9_fht8x8_c, &vp9_iht8x8_64_add_c, 1, VPX_BITS_8),
make_tuple(&vp9_fht8x8_c, &vp9_iht8x8_64_add_c, 2, VPX_BITS_8),

266
test/vp9_intrapred_test.cc
Просмотреть файл

@ -134,150 +134,164 @@ using std::tr1::make_tuple;
#if ARCH_X86_64
INSTANTIATE_TEST_CASE_P(SSE2_TO_C_8, VP9IntraPredTest,
::testing::Values(
make_tuple(&vp9_high_dc_predictor_32x32_sse2,
&vp9_high_dc_predictor_32x32_c, 32, 8),
make_tuple(&vp9_high_tm_predictor_16x16_sse2,
&vp9_high_tm_predictor_16x16_c, 16, 8),
make_tuple(&vp9_high_tm_predictor_32x32_sse2,
&vp9_high_tm_predictor_32x32_c, 32, 8),
make_tuple(&vp9_high_dc_predictor_4x4_sse,
&vp9_high_dc_predictor_4x4_c, 4, 8),
make_tuple(&vp9_high_dc_predictor_8x8_sse2,
&vp9_high_dc_predictor_8x8_c, 8, 8),
make_tuple(&vp9_high_dc_predictor_16x16_sse2,
&vp9_high_dc_predictor_16x16_c, 16, 8),
make_tuple(&vp9_high_v_predictor_4x4_sse,
&vp9_high_v_predictor_4x4_c, 4, 8),
make_tuple(&vp9_high_v_predictor_8x8_sse2,
&vp9_high_v_predictor_8x8_c, 8, 8),
make_tuple(&vp9_high_v_predictor_16x16_sse2,
&vp9_high_v_predictor_16x16_c, 16, 8),
make_tuple(&vp9_high_v_predictor_32x32_sse2,
&vp9_high_v_predictor_32x32_c, 32, 8),
make_tuple(&vp9_high_tm_predictor_4x4_sse,
&vp9_high_tm_predictor_4x4_c, 4, 8),
make_tuple(&vp9_high_tm_predictor_8x8_sse2,
&vp9_high_tm_predictor_8x8_c, 8, 8)));
make_tuple(&vp9_highbd_dc_predictor_32x32_sse2,
&vp9_highbd_dc_predictor_32x32_c, 32, 8),
make_tuple(&vp9_highbd_tm_predictor_16x16_sse2,
&vp9_highbd_tm_predictor_16x16_c, 16, 8),
make_tuple(&vp9_highbd_tm_predictor_32x32_sse2,
&vp9_highbd_tm_predictor_32x32_c, 32, 8),
make_tuple(&vp9_highbd_dc_predictor_4x4_sse,
&vp9_highbd_dc_predictor_4x4_c, 4, 8),
make_tuple(&vp9_highbd_dc_predictor_8x8_sse2,
&vp9_highbd_dc_predictor_8x8_c, 8, 8),
make_tuple(&vp9_highbd_dc_predictor_16x16_sse2,
&vp9_highbd_dc_predictor_16x16_c, 16, 8),
make_tuple(&vp9_highbd_v_predictor_4x4_sse,
&vp9_highbd_v_predictor_4x4_c, 4, 8),
make_tuple(&vp9_highbd_v_predictor_8x8_sse2,
&vp9_highbd_v_predictor_8x8_c, 8, 8),
make_tuple(&vp9_highbd_v_predictor_16x16_sse2,
&vp9_highbd_v_predictor_16x16_c, 16, 8),
make_tuple(&vp9_highbd_v_predictor_32x32_sse2,
&vp9_highbd_v_predictor_32x32_c, 32, 8),
make_tuple(&vp9_highbd_tm_predictor_4x4_sse,
&vp9_highbd_tm_predictor_4x4_c, 4, 8),
make_tuple(&vp9_highbd_tm_predictor_8x8_sse2,
&vp9_highbd_tm_predictor_8x8_c, 8, 8)));
#else
INSTANTIATE_TEST_CASE_P(SSE2_TO_C_8, VP9IntraPredTest,
::testing::Values(
make_tuple(&vp9_high_dc_predictor_4x4_sse,
&vp9_high_dc_predictor_4x4_c, 4, 8),
make_tuple(&vp9_high_dc_predictor_8x8_sse2,
&vp9_high_dc_predictor_8x8_c, 8, 8),
make_tuple(&vp9_high_dc_predictor_16x16_sse2,
&vp9_high_dc_predictor_16x16_c, 16, 8),
make_tuple(&vp9_high_v_predictor_4x4_sse,
&vp9_high_v_predictor_4x4_c, 4, 8),
make_tuple(&vp9_high_v_predictor_8x8_sse2,
&vp9_high_v_predictor_8x8_c, 8, 8),
make_tuple(&vp9_high_v_predictor_16x16_sse2,
&vp9_high_v_predictor_16x16_c, 16, 8),
make_tuple(&vp9_high_v_predictor_32x32_sse2,
&vp9_high_v_predictor_32x32_c, 32, 8),
make_tuple(&vp9_high_tm_predictor_4x4_sse,
&vp9_high_tm_predictor_4x4_c, 4, 8),
make_tuple(&vp9_high_tm_predictor_8x8_sse2,
&vp9_high_tm_predictor_8x8_c, 8, 8)));
make_tuple(&vp9_highbd_dc_predictor_4x4_sse,
&vp9_highbd_dc_predictor_4x4_c, 4, 8),
make_tuple(&vp9_highbd_dc_predictor_8x8_sse2,
&vp9_highbd_dc_predictor_8x8_c, 8, 8),
make_tuple(&vp9_highbd_dc_predictor_16x16_sse2,
&vp9_highbd_dc_predictor_16x16_c, 16, 8),
make_tuple(&vp9_highbd_v_predictor_4x4_sse,
&vp9_highbd_v_predictor_4x4_c, 4, 8),
make_tuple(&vp9_highbd_v_predictor_8x8_sse2,
&vp9_highbd_v_predictor_8x8_c, 8, 8),
make_tuple(&vp9_highbd_v_predictor_16x16_sse2,
&vp9_highbd_v_predictor_16x16_c, 16, 8),
make_tuple(&vp9_highbd_v_predictor_32x32_sse2,
&vp9_highbd_v_predictor_32x32_c, 32, 8),
make_tuple(&vp9_highbd_tm_predictor_4x4_sse,
&vp9_highbd_tm_predictor_4x4_c, 4, 8),
make_tuple(&vp9_highbd_tm_predictor_8x8_sse2,
&vp9_highbd_tm_predictor_8x8_c, 8, 8)));
#endif
#if ARCH_X86_64
INSTANTIATE_TEST_CASE_P(SSE2_TO_C_10, VP9IntraPredTest,
::testing::Values(
make_tuple(&vp9_high_dc_predictor_32x32_sse2,
&vp9_high_dc_predictor_32x32_c, 32, 10),
make_tuple(&vp9_high_tm_predictor_16x16_sse2,
&vp9_high_tm_predictor_16x16_c, 16, 10),
make_tuple(&vp9_high_tm_predictor_32x32_sse2,
&vp9_high_tm_predictor_32x32_c, 32, 10),
make_tuple(&vp9_high_dc_predictor_4x4_sse,
&vp9_high_dc_predictor_4x4_c, 4, 10),
make_tuple(&vp9_high_dc_predictor_8x8_sse2,
&vp9_high_dc_predictor_8x8_c, 8, 10),
make_tuple(&vp9_high_dc_predictor_16x16_sse2,
&vp9_high_dc_predictor_16x16_c, 16, 10),
make_tuple(&vp9_high_v_predictor_4x4_sse,
&vp9_high_v_predictor_4x4_c, 4, 10),
make_tuple(&vp9_high_v_predictor_8x8_sse2,
&vp9_high_v_predictor_8x8_c, 8, 10),
make_tuple(&vp9_high_v_predictor_16x16_sse2,
&vp9_high_v_predictor_16x16_c, 16, 10),
make_tuple(&vp9_high_v_predictor_32x32_sse2,
&vp9_high_v_predictor_32x32_c, 32, 10),
make_tuple(&vp9_high_tm_predictor_4x4_sse,
&vp9_high_tm_predictor_4x4_c, 4, 10),
make_tuple(&vp9_high_tm_predictor_8x8_sse2,
&vp9_high_tm_predictor_8x8_c, 8, 10)));
make_tuple(&vp9_highbd_dc_predictor_32x32_sse2,
&vp9_highbd_dc_predictor_32x32_c, 32,
10),
make_tuple(&vp9_highbd_tm_predictor_16x16_sse2,
&vp9_highbd_tm_predictor_16x16_c, 16,
10),
make_tuple(&vp9_highbd_tm_predictor_32x32_sse2,
&vp9_highbd_tm_predictor_32x32_c, 32,
10),
make_tuple(&vp9_highbd_dc_predictor_4x4_sse,
&vp9_highbd_dc_predictor_4x4_c, 4, 10),
make_tuple(&vp9_highbd_dc_predictor_8x8_sse2,
&vp9_highbd_dc_predictor_8x8_c, 8, 10),
make_tuple(&vp9_highbd_dc_predictor_16x16_sse2,
&vp9_highbd_dc_predictor_16x16_c, 16,
10),
make_tuple(&vp9_highbd_v_predictor_4x4_sse,
&vp9_highbd_v_predictor_4x4_c, 4, 10),
make_tuple(&vp9_highbd_v_predictor_8x8_sse2,
&vp9_highbd_v_predictor_8x8_c, 8, 10),
make_tuple(&vp9_highbd_v_predictor_16x16_sse2,
&vp9_highbd_v_predictor_16x16_c, 16,
10),
make_tuple(&vp9_highbd_v_predictor_32x32_sse2,
&vp9_highbd_v_predictor_32x32_c, 32,
10),
make_tuple(&vp9_highbd_tm_predictor_4x4_sse,
&vp9_highbd_tm_predictor_4x4_c, 4, 10),
make_tuple(&vp9_highbd_tm_predictor_8x8_sse2,
&vp9_highbd_tm_predictor_8x8_c, 8, 10)));
#else
INSTANTIATE_TEST_CASE_P(SSE2_TO_C_10, VP9IntraPredTest,
::testing::Values(
make_tuple(&vp9_high_dc_predictor_4x4_sse,
&vp9_high_dc_predictor_4x4_c, 4, 10),
make_tuple(&vp9_high_dc_predictor_8x8_sse2,
&vp9_high_dc_predictor_8x8_c, 8, 10),
make_tuple(&vp9_high_dc_predictor_16x16_sse2,
&vp9_high_dc_predictor_16x16_c, 16, 10),
make_tuple(&vp9_high_v_predictor_4x4_sse,
&vp9_high_v_predictor_4x4_c, 4, 10),
make_tuple(&vp9_high_v_predictor_8x8_sse2,
&vp9_high_v_predictor_8x8_c, 8, 10),
make_tuple(&vp9_high_v_predictor_16x16_sse2,
&vp9_high_v_predictor_16x16_c, 16, 10),
make_tuple(&vp9_high_v_predictor_32x32_sse2,
&vp9_high_v_predictor_32x32_c, 32, 10),
make_tuple(&vp9_high_tm_predictor_4x4_sse,
&vp9_high_tm_predictor_4x4_c, 4, 10),
make_tuple(&vp9_high_tm_predictor_8x8_sse2,
&vp9_high_tm_predictor_8x8_c, 8, 10)));
make_tuple(&vp9_highbd_dc_predictor_4x4_sse,
&vp9_highbd_dc_predictor_4x4_c, 4, 10),
make_tuple(&vp9_highbd_dc_predictor_8x8_sse2,
&vp9_highbd_dc_predictor_8x8_c, 8, 10),
make_tuple(&vp9_highbd_dc_predictor_16x16_sse2,
&vp9_highbd_dc_predictor_16x16_c, 16,
10),
make_tuple(&vp9_highbd_v_predictor_4x4_sse,
&vp9_highbd_v_predictor_4x4_c, 4, 10),
make_tuple(&vp9_highbd_v_predictor_8x8_sse2,
&vp9_highbd_v_predictor_8x8_c, 8, 10),
make_tuple(&vp9_highbd_v_predictor_16x16_sse2,
&vp9_highbd_v_predictor_16x16_c, 16, 10),
make_tuple(&vp9_highbd_v_predictor_32x32_sse2,
&vp9_highbd_v_predictor_32x32_c, 32, 10),
make_tuple(&vp9_highbd_tm_predictor_4x4_sse,
&vp9_highbd_tm_predictor_4x4_c, 4, 10),
make_tuple(&vp9_highbd_tm_predictor_8x8_sse2,
&vp9_highbd_tm_predictor_8x8_c, 8, 10)));
#endif
#if ARCH_X86_64
INSTANTIATE_TEST_CASE_P(SSE2_TO_C_12, VP9IntraPredTest,
::testing::Values(
make_tuple(&vp9_high_dc_predictor_32x32_sse2,
&vp9_high_dc_predictor_32x32_c, 32, 12),
make_tuple(&vp9_high_tm_predictor_16x16_sse2,
&vp9_high_tm_predictor_16x16_c, 16, 12),
make_tuple(&vp9_high_tm_predictor_32x32_sse2,
&vp9_high_tm_predictor_32x32_c, 32, 12),
make_tuple(&vp9_high_dc_predictor_4x4_sse,
&vp9_high_dc_predictor_4x4_c, 4, 12),
make_tuple(&vp9_high_dc_predictor_8x8_sse2,
&vp9_high_dc_predictor_8x8_c, 8, 12),
make_tuple(&vp9_high_dc_predictor_16x16_sse2,
&vp9_high_dc_predictor_16x16_c, 16, 12),
make_tuple(&vp9_high_v_predictor_4x4_sse,
&vp9_high_v_predictor_4x4_c, 4, 12),
make_tuple(&vp9_high_v_predictor_8x8_sse2,
&vp9_high_v_predictor_8x8_c, 8, 12),
make_tuple(&vp9_high_v_predictor_16x16_sse2,
&vp9_high_v_predictor_16x16_c, 16, 12),
make_tuple(&vp9_high_v_predictor_32x32_sse2,
&vp9_high_v_predictor_32x32_c, 32, 12),
make_tuple(&vp9_high_tm_predictor_4x4_sse,
&vp9_high_tm_predictor_4x4_c, 4, 12),
make_tuple(&vp9_high_tm_predictor_8x8_sse2,
&vp9_high_tm_predictor_8x8_c, 8, 12)));
make_tuple(&vp9_highbd_dc_predictor_32x32_sse2,
&vp9_highbd_dc_predictor_32x32_c, 32,
12),
make_tuple(&vp9_highbd_tm_predictor_16x16_sse2,
&vp9_highbd_tm_predictor_16x16_c, 16,
12),
make_tuple(&vp9_highbd_tm_predictor_32x32_sse2,
&vp9_highbd_tm_predictor_32x32_c, 32,
12),
make_tuple(&vp9_highbd_dc_predictor_4x4_sse,
&vp9_highbd_dc_predictor_4x4_c, 4, 12),
make_tuple(&vp9_highbd_dc_predictor_8x8_sse2,
&vp9_highbd_dc_predictor_8x8_c, 8, 12),
make_tuple(&vp9_highbd_dc_predictor_16x16_sse2,
&vp9_highbd_dc_predictor_16x16_c, 16,
12),
make_tuple(&vp9_highbd_v_predictor_4x4_sse,
&vp9_highbd_v_predictor_4x4_c, 4, 12),
make_tuple(&vp9_highbd_v_predictor_8x8_sse2,
&vp9_highbd_v_predictor_8x8_c, 8, 12),
make_tuple(&vp9_highbd_v_predictor_16x16_sse2,
&vp9_highbd_v_predictor_16x16_c, 16,
12),
make_tuple(&vp9_highbd_v_predictor_32x32_sse2,
&vp9_highbd_v_predictor_32x32_c, 32,
12),
make_tuple(&vp9_highbd_tm_predictor_4x4_sse,
&vp9_highbd_tm_predictor_4x4_c, 4, 12),
make_tuple(&vp9_highbd_tm_predictor_8x8_sse2,
&vp9_highbd_tm_predictor_8x8_c, 8, 12)));
#else
INSTANTIATE_TEST_CASE_P(SSE2_TO_C_12, VP9IntraPredTest,
::testing::Values(
make_tuple(&vp9_high_dc_predictor_4x4_sse,
&vp9_high_dc_predictor_4x4_c, 4, 12),
make_tuple(&vp9_high_dc_predictor_8x8_sse2,
&vp9_high_dc_predictor_8x8_c, 8, 12),
make_tuple(&vp9_high_dc_predictor_16x16_sse2,
&vp9_high_dc_predictor_16x16_c, 16, 12),
make_tuple(&vp9_high_v_predictor_4x4_sse,
&vp9_high_v_predictor_4x4_c, 4, 12),
make_tuple(&vp9_high_v_predictor_8x8_sse2,
&vp9_high_v_predictor_8x8_c, 8, 12),
make_tuple(&vp9_high_v_predictor_16x16_sse2,
&vp9_high_v_predictor_16x16_c, 16, 12),
make_tuple(&vp9_high_v_predictor_32x32_sse2,
&vp9_high_v_predictor_32x32_c, 32, 12),
make_tuple(&vp9_high_tm_predictor_4x4_sse,
&vp9_high_tm_predictor_4x4_c, 4, 12),
make_tuple(&vp9_high_tm_predictor_8x8_sse2,
&vp9_high_tm_predictor_8x8_c, 8, 12)));
make_tuple(&vp9_highbd_dc_predictor_4x4_sse,
&vp9_highbd_dc_predictor_4x4_c, 4, 12),
make_tuple(&vp9_highbd_dc_predictor_8x8_sse2,
&vp9_highbd_dc_predictor_8x8_c, 8, 12),
make_tuple(&vp9_highbd_dc_predictor_16x16_sse2,
&vp9_highbd_dc_predictor_16x16_c, 16,
12),
make_tuple(&vp9_highbd_v_predictor_4x4_sse,
&vp9_highbd_v_predictor_4x4_c, 4, 12),
make_tuple(&vp9_highbd_v_predictor_8x8_sse2,
&vp9_highbd_v_predictor_8x8_c, 8, 12),
make_tuple(&vp9_highbd_v_predictor_16x16_sse2,
&vp9_highbd_v_predictor_16x16_c, 16, 12),
make_tuple(&vp9_highbd_v_predictor_32x32_sse2,
&vp9_highbd_v_predictor_32x32_c, 32, 12),
make_tuple(&vp9_highbd_tm_predictor_4x4_sse,
&vp9_highbd_tm_predictor_4x4_c, 4, 12),
make_tuple(&vp9_highbd_tm_predictor_8x8_sse2,
&vp9_highbd_tm_predictor_8x8_c, 8, 12)));
#endif
#endif // CONFIG_VP9_HIGHBITDEPTH
#endif // HAVE_SSE2

242
vp9/common/vp9_convolve.c
Просмотреть файл

@ -282,11 +282,11 @@ void vp9_convolve_avg_c(const uint8_t *src, ptrdiff_t src_stride,
}
#if CONFIG_VP9_HIGHBITDEPTH
static void high_convolve_horiz(const uint8_t *src8, ptrdiff_t src_stride,
uint8_t *dst8, ptrdiff_t dst_stride,
const InterpKernel *x_filters,
int x0_q4, int x_step_q4,
int w, int h, int bd) {
static void highbd_convolve_horiz(const uint8_t *src8, ptrdiff_t src_stride,
uint8_t *dst8, ptrdiff_t dst_stride,
const InterpKernel *x_filters,
int x0_q4, int x_step_q4,
int w, int h, int bd) {
int x, y;
uint16_t *src = CONVERT_TO_SHORTPTR(src8);
uint16_t *dst = CONVERT_TO_SHORTPTR(dst8);
@ -307,11 +307,11 @@ static void high_convolve_horiz(const uint8_t *src8, ptrdiff_t src_stride,
}
}
static void high_convolve_avg_horiz(const uint8_t *src8, ptrdiff_t src_stride,
uint8_t *dst8, ptrdiff_t dst_stride,
const InterpKernel *x_filters,
int x0_q4, int x_step_q4,
int w, int h, int bd) {
static void highbd_convolve_avg_horiz(const uint8_t *src8, ptrdiff_t src_stride,
uint8_t *dst8, ptrdiff_t dst_stride,
const InterpKernel *x_filters,
int x0_q4, int x_step_q4,
int w, int h, int bd) {
int x, y;
uint16_t *src = CONVERT_TO_SHORTPTR(src8);
uint16_t *dst = CONVERT_TO_SHORTPTR(dst8);
@ -333,11 +333,11 @@ static void high_convolve_avg_horiz(const uint8_t *src8, ptrdiff_t src_stride,
}
}
static void high_convolve_vert(const uint8_t *src8, ptrdiff_t src_stride,
uint8_t *dst8, ptrdiff_t dst_stride,
const InterpKernel *y_filters,
int y0_q4, int y_step_q4, int w, int h,
int bd) {
static void highbd_convolve_vert(const uint8_t *src8, ptrdiff_t src_stride,
uint8_t *dst8, ptrdiff_t dst_stride,
const InterpKernel *y_filters,
int y0_q4, int y_step_q4, int w, int h,
int bd) {
int x, y;
uint16_t *src = CONVERT_TO_SHORTPTR(src8);
uint16_t *dst = CONVERT_TO_SHORTPTR(dst8);
@ -359,11 +359,11 @@ static void high_convolve_vert(const uint8_t *src8, ptrdiff_t src_stride,
}
}
static void high_convolve_avg_vert(const uint8_t *src8, ptrdiff_t src_stride,
uint8_t *dst8, ptrdiff_t dst_stride,
const InterpKernel *y_filters,
int y0_q4, int y_step_q4, int w, int h,
int bd) {
static void highbd_convolve_avg_vert(const uint8_t *src8, ptrdiff_t src_stride,
uint8_t *dst8, ptrdiff_t dst_stride,
const InterpKernel *y_filters,
int y0_q4, int y_step_q4, int w, int h,
int bd) {
int x, y;
uint16_t *src = CONVERT_TO_SHORTPTR(src8);
uint16_t *dst = CONVERT_TO_SHORTPTR(dst8);
@ -385,13 +385,13 @@ static void high_convolve_avg_vert(const uint8_t *src8, ptrdiff_t src_stride,
}
}
static void high_convolve(const uint8_t *src, ptrdiff_t src_stride,
uint8_t *dst, ptrdiff_t dst_stride,
const InterpKernel *const x_filters,
int x0_q4, int x_step_q4,
const InterpKernel *const y_filters,
int y0_q4, int y_step_q4,
int w, int h, int bd) {
static void highbd_convolve(const uint8_t *src, ptrdiff_t src_stride,
uint8_t *dst, ptrdiff_t dst_stride,
const InterpKernel *const x_filters,
int x0_q4, int x_step_q4,
const InterpKernel *const y_filters,
int y0_q4, int y_step_q4,
int w, int h, int bd) {
// Note: Fixed size intermediate buffer, temp, places limits on parameters.
// 2d filtering proceeds in 2 steps:
// (1) Interpolate horizontally into an intermediate buffer, temp.
@ -413,109 +413,109 @@ static void high_convolve(const uint8_t *src, ptrdiff_t src_stride,
assert(y_step_q4 <= 32);
assert(x_step_q4 <= 32);
high_convolve_horiz(src - src_stride * (SUBPEL_TAPS / 2 - 1),
src_stride, CONVERT_TO_BYTEPTR(temp), 64,
x_filters, x0_q4, x_step_q4, w,
intermediate_height, bd);
high_convolve_vert(CONVERT_TO_BYTEPTR(temp) + 64 * (SUBPEL_TAPS / 2 - 1),
64, dst, dst_stride, y_filters, y0_q4, y_step_q4,
w, h, bd);
highbd_convolve_horiz(src - src_stride * (SUBPEL_TAPS / 2 - 1),
src_stride, CONVERT_TO_BYTEPTR(temp), 64,
x_filters, x0_q4, x_step_q4, w,
intermediate_height, bd);
highbd_convolve_vert(CONVERT_TO_BYTEPTR(temp) + 64 * (SUBPEL_TAPS / 2 - 1),
64, dst, dst_stride, y_filters, y0_q4, y_step_q4,
w, h, bd);
}
void vp9_high_convolve8_horiz_c(const uint8_t *src, ptrdiff_t src_stride,
void vp9_highbd_convolve8_horiz_c(const uint8_t *src, ptrdiff_t src_stride,
uint8_t *dst, ptrdiff_t dst_stride,
const int16_t *filter_x, int x_step_q4,
const int16_t *filter_y, int y_step_q4,
int w, int h, int bd) {
const InterpKernel *const filters_x = get_filter_base(filter_x);
const int x0_q4 = get_filter_offset(filter_x, filters_x);
(void)filter_y;
(void)y_step_q4;
highbd_convolve_horiz(src, src_stride, dst, dst_stride, filters_x,
x0_q4, x_step_q4, w, h, bd);
}
void vp9_highbd_convolve8_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride,
uint8_t *dst, ptrdiff_t dst_stride,
const int16_t *filter_x, int x_step_q4,
const int16_t *filter_y, int y_step_q4,
int w, int h, int bd) {
const InterpKernel *const filters_x = get_filter_base(filter_x);
const int x0_q4 = get_filter_offset(filter_x, filters_x);
(void)filter_y;
(void)y_step_q4;
highbd_convolve_avg_horiz(src, src_stride, dst, dst_stride, filters_x,
x0_q4, x_step_q4, w, h, bd);
}
void vp9_highbd_convolve8_vert_c(const uint8_t *src, ptrdiff_t src_stride,
uint8_t *dst, ptrdiff_t dst_stride,
const int16_t *filter_x, int x_step_q4,
const int16_t *filter_y, int y_step_q4,
int w, int h, int bd) {
const InterpKernel *const filters_y = get_filter_base(filter_y);
const int y0_q4 = get_filter_offset(filter_y, filters_y);
(void)filter_x;
(void)x_step_q4;
highbd_convolve_vert(src, src_stride, dst, dst_stride, filters_y,
y0_q4, y_step_q4, w, h, bd);
}
void vp9_highbd_convolve8_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride,
uint8_t *dst, ptrdiff_t dst_stride,
const int16_t *filter_x, int x_step_q4,
const int16_t *filter_y, int y_step_q4,
int w, int h, int bd) {
const InterpKernel *const filters_y = get_filter_base(filter_y);
const int y0_q4 = get_filter_offset(filter_y, filters_y);
(void)filter_x;
(void)x_step_q4;
highbd_convolve_avg_vert(src, src_stride, dst, dst_stride, filters_y,
y0_q4, y_step_q4, w, h, bd);
}
void vp9_highbd_convolve8_c(const uint8_t *src, ptrdiff_t src_stride,
uint8_t *dst, ptrdiff_t dst_stride,
const int16_t *filter_x, int x_step_q4,
const int16_t *filter_y, int y_step_q4,
int w, int h, int bd) {
const InterpKernel *const filters_x = get_filter_base(filter_x);
const int x0_q4 = get_filter_offset(filter_x, filters_x);
const InterpKernel *const filters_y = get_filter_base(filter_y);
const int y0_q4 = get_filter_offset(filter_y, filters_y);
highbd_convolve(src, src_stride, dst, dst_stride,
filters_x, x0_q4, x_step_q4,
filters_y, y0_q4, y_step_q4, w, h, bd);
}
void vp9_highbd_convolve8_avg_c(const uint8_t *src, ptrdiff_t src_stride,
uint8_t *dst, ptrdiff_t dst_stride,
const int16_t *filter_x, int x_step_q4,
const int16_t *filter_y, int y_step_q4,
int w, int h, int bd) {
const InterpKernel *const filters_x = get_filter_base(filter_x);
const int x0_q4 = get_filter_offset(filter_x, filters_x);
(void)filter_y;
(void)y_step_q4;
high_convolve_horiz(src, src_stride, dst, dst_stride, filters_x,
x0_q4, x_step_q4, w, h, bd);
}
void vp9_high_convolve8_avg_horiz_c(const uint8_t *src, ptrdiff_t src_stride,
uint8_t *dst, ptrdiff_t dst_stride,
const int16_t *filter_x, int x_step_q4,
const int16_t *filter_y, int y_step_q4,
int w, int h, int bd) {
const InterpKernel *const filters_x = get_filter_base(filter_x);
const int x0_q4 = get_filter_offset(filter_x, filters_x);
(void)filter_y;
(void)y_step_q4;
high_convolve_avg_horiz(src, src_stride, dst, dst_stride, filters_x,
x0_q4, x_step_q4, w, h, bd);
}
void vp9_high_convolve8_vert_c(const uint8_t *src, ptrdiff_t src_stride,
uint8_t *dst, ptrdiff_t dst_stride,
const int16_t *filter_x, int x_step_q4,
const int16_t *filter_y, int y_step_q4,
int w, int h, int bd) {
const InterpKernel *const filters_y = get_filter_base(filter_y);
const int y0_q4 = get_filter_offset(filter_y, filters_y);
(void)filter_x;
(void)x_step_q4;
high_convolve_vert(src, src_stride, dst, dst_stride, filters_y,
y0_q4, y_step_q4, w, h, bd);
}
void vp9_high_convolve8_avg_vert_c(const uint8_t *src, ptrdiff_t src_stride,
uint8_t *dst, ptrdiff_t dst_stride,
const int16_t *filter_x, int x_step_q4,
const int16_t *filter_y, int y_step_q4,
int w, int h, int bd) {
const InterpKernel *const filters_y = get_filter_base(filter_y);
const int y0_q4 = get_filter_offset(filter_y, filters_y);
(void)filter_x;
(void)x_step_q4;
high_convolve_avg_vert(src, src_stride, dst, dst_stride, filters_y,
y0_q4, y_step_q4, w, h, bd);
}
void vp9_high_convolve8_c(const uint8_t *src, ptrdiff_t src_stride,
uint8_t *dst, ptrdiff_t dst_stride,
const int16_t *filter_x, int x_step_q4,
const int16_t *filter_y, int y_step_q4,
int w, int h, int bd) {
const InterpKernel *const filters_x = get_filter_base(filter_x);
const int x0_q4 = get_filter_offset(filter_x, filters_x);
const InterpKernel *const filters_y = get_filter_base(filter_y);
const int y0_q4 = get_filter_offset(filter_y, filters_y);
high_convolve(src, src_stride, dst, dst_stride,
filters_x, x0_q4, x_step_q4,
filters_y, y0_q4, y_step_q4, w, h, bd);
}
void vp9_high_convolve8_avg_c(const uint8_t *src, ptrdiff_t src_stride,
uint8_t *dst, ptrdiff_t dst_stride,
const int16_t *filter_x, int x_step_q4,
const int16_t *filter_y, int y_step_q4,
int w, int h, int bd) {
// Fixed size intermediate buffer places limits on parameters.
DECLARE_ALIGNED_ARRAY(16, uint16_t, temp, 64 * 64);
assert(w <= 64);
assert(h <= 64);
vp9_high_convolve8_c(src, src_stride, CONVERT_TO_BYTEPTR(temp), 64,
filter_x, x_step_q4, filter_y, y_step_q4, w, h, bd);
vp9_high_convolve_avg_c(CONVERT_TO_BYTEPTR(temp), 64, dst, dst_stride,
NULL, 0, NULL, 0, w, h, bd);
vp9_highbd_convolve8_c(src, src_stride, CONVERT_TO_BYTEPTR(temp), 64,
filter_x, x_step_q4, filter_y, y_step_q4, w, h, bd);
vp9_highbd_convolve_avg_c(CONVERT_TO_BYTEPTR(temp), 64, dst, dst_stride,
NULL, 0, NULL, 0, w, h, bd);
}
void vp9_high_convolve_copy_c(const uint8_t *src8, ptrdiff_t src_stride,
uint8_t *dst8, ptrdiff_t dst_stride,
const int16_t *filter_x, int filter_x_stride,
const int16_t *filter_y, int filter_y_stride,
int w, int h, int bd) {
void vp9_highbd_convolve_copy_c(const uint8_t *src8, ptrdiff_t src_stride,
uint8_t *dst8, ptrdiff_t dst_stride,
const int16_t *filter_x, int filter_x_stride,
const int16_t *filter_y, int filter_y_stride,
int w, int h, int bd) {
int r;
uint16_t *src = CONVERT_TO_SHORTPTR(src8);
uint16_t *dst = CONVERT_TO_SHORTPTR(dst8);
@ -532,11 +532,11 @@ void vp9_high_convolve_copy_c(const uint8_t *src8, ptrdiff_t src_stride,
}
}
void vp9_high_convolve_avg_c(const uint8_t *src8, ptrdiff_t src_stride,
uint8_t *dst8, ptrdiff_t dst_stride,
const int16_t *filter_x, int filter_x_stride,
const int16_t *filter_y, int filter_y_stride,
int w, int h, int bd) {
void vp9_highbd_convolve_avg_c(const uint8_t *src8, ptrdiff_t src_stride,
uint8_t *dst8, ptrdiff_t dst_stride,
const int16_t *filter_x, int filter_x_stride,
const int16_t *filter_y, int filter_y_stride,
int w, int h, int bd) {
int x, y;
uint16_t *src = CONVERT_TO_SHORTPTR(src8);
uint16_t *dst = CONVERT_TO_SHORTPTR(dst8);

10
vp9/common/vp9_convolve.h
Просмотреть файл

@ -24,11 +24,11 @@ typedef void (*convolve_fn_t)(const uint8_t *src, ptrdiff_t src_stride,
int w, int h);
#if CONFIG_VP9_HIGHBITDEPTH
typedef void (*high_convolve_fn_t)(const uint8_t *src, ptrdiff_t src_stride,
uint8_t *dst, ptrdiff_t dst_stride,
const int16_t *filter_x, int x_step_q4,
const int16_t *filter_y, int y_step_q4,
int w, int h, int bd);
typedef void (*highbd_convolve_fn_t)(const uint8_t *src, ptrdiff_t src_stride,
uint8_t *dst, ptrdiff_t dst_stride,
const int16_t *filter_x, int x_step_q4,
const int16_t *filter_y, int y_step_q4,
int w, int h, int bd);
#endif
#ifdef __cplusplus

142
vp9/common/vp9_idct.c
Просмотреть файл

@ -1458,8 +1458,8 @@ void vp9_iht16x16_add(TX_TYPE tx_type, const tran_low_t *input, uint8_t *dest,
}
#if CONFIG_VP9_HIGHBITDEPTH
void vp9_high_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
void vp9_highbd_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
/* 4-point reversible, orthonormal inverse Walsh-Hadamard in 3.5 adds,
0.5 shifts per pixel. */
int i;
@ -1512,8 +1512,8 @@ void vp9_high_iwht4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
}
}
void vp9_high_iwht4x4_1_add_c(const tran_low_t *in, uint8_t *dest8,
int dest_stride, int bd) {
void vp9_highbd_iwht4x4_1_add_c(const tran_low_t *in, uint8_t *dest8,
int dest_stride, int bd) {
int i;
tran_high_t a1, e1;
tran_low_t tmp[4];
@ -1566,8 +1566,8 @@ static void highbd_idct4(const tran_low_t *input, tran_low_t *output, int bd) {
output[3] = WRAPLOW(step[0] - step[3], bd);
}
void vp9_high_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
void vp9_highbd_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
tran_low_t out[4 * 4];
tran_low_t *outptr = out;
int i, j;
@ -1593,8 +1593,8 @@ void vp9_high_idct4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
}
}
void vp9_high_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest8,
int dest_stride, int bd) {
void vp9_highbd_idct4x4_1_add_c(const tran_low_t *input, uint8_t *dest8,
int dest_stride, int bd) {
int i;
tran_high_t a1;
tran_low_t out = WRAPLOW(dct_const_round_shift(input[0] * cospi_16_64), bd);
@ -1657,8 +1657,8 @@ static void highbd_idct8(const tran_low_t *input, tran_low_t *output, int bd) {
output[7] = WRAPLOW(step1[0] - step1[7], bd);
}
void vp9_high_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
void vp9_highbd_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
tran_low_t out[8 * 8];
tran_low_t *outptr = out;
int i, j;
@ -1684,8 +1684,8 @@ void vp9_high_idct8x8_64_add_c(const tran_low_t *input, uint8_t *dest8,
}
}
void vp9_high_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
void vp9_highbd_idct8x8_1_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
int i, j;
tran_high_t a1;
tran_low_t out = WRAPLOW(dct_const_round_shift(input[0] * cospi_16_64), bd);
@ -1742,9 +1742,9 @@ static void highbd_iadst4(const tran_low_t *input, tran_low_t *output, int bd) {
output[3] = WRAPLOW(dct_const_round_shift(s3), bd);
}
void vp9_high_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int tx_type, int bd) {
const high_transform_2d IHT_4[] = {
void vp9_highbd_iht4x4_16_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int tx_type, int bd) {
const highbd_transform_2d IHT_4[] = {
{ highbd_idct4, highbd_idct4 }, // DCT_DCT = 0
{ highbd_iadst4, highbd_idct4 }, // ADST_DCT = 1
{ highbd_idct4, highbd_iadst4 }, // DCT_ADST = 2
@ -1853,20 +1853,20 @@ static void highbd_iadst8(const tran_low_t *input, tran_low_t *output, int bd) {
output[7] = WRAPLOW(-x1, bd);
}
static const high_transform_2d HIGH_IHT_8[] = {
static const highbd_transform_2d HIGH_IHT_8[] = {
{ highbd_idct8, highbd_idct8 }, // DCT_DCT = 0
{ highbd_iadst8, highbd_idct8 }, // ADST_DCT = 1
{ highbd_idct8, highbd_iadst8 }, // DCT_ADST = 2
{ highbd_iadst8, highbd_iadst8 } // ADST_ADST = 3
};
void vp9_high_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int tx_type, int bd) {
void vp9_highbd_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int tx_type, int bd) {
int i, j;
tran_low_t out[8 * 8];
tran_low_t *outptr = out;
tran_low_t temp_in[8], temp_out[8];
const high_transform_2d ht = HIGH_IHT_8[tx_type];
const highbd_transform_2d ht = HIGH_IHT_8[tx_type];
uint16_t *dest = CONVERT_TO_SHORTPTR(dest8);
// Inverse transform row vectors.
@ -1888,8 +1888,8 @@ void vp9_high_iht8x8_64_add_c(const tran_low_t *input, uint8_t *dest8,
}
}
void vp9_high_idct8x8_10_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
void vp9_highbd_idct8x8_10_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
tran_low_t out[8 * 8] = { 0 };
tran_low_t *outptr = out;
int i, j;
@ -2081,8 +2081,8 @@ static void highbd_idct16(const tran_low_t *input, tran_low_t *output, int bd) {
output[15] = WRAPLOW(step2[0] - step2[15], bd);
}
void vp9_high_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
void vp9_highbd_idct16x16_256_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
tran_low_t out[16 * 16];
tran_low_t *outptr = out;
int i, j;
@ -2279,20 +2279,20 @@ static void highbd_iadst16(const tran_low_t *input, tran_low_t *output,
output[15] = WRAPLOW(-x1, bd);
}
static const high_transform_2d HIGH_IHT_16[] = {
static const highbd_transform_2d HIGH_IHT_16[] = {
{ highbd_idct16, highbd_idct16 }, // DCT_DCT = 0
{ highbd_iadst16, highbd_idct16 }, // ADST_DCT = 1
{ highbd_idct16, highbd_iadst16 }, // DCT_ADST = 2
{ highbd_iadst16, highbd_iadst16 } // ADST_ADST = 3
};
void vp9_high_iht16x16_256_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int tx_type, int bd) {
void vp9_highbd_iht16x16_256_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int tx_type, int bd) {
int i, j;
tran_low_t out[16 * 16];
tran_low_t *outptr = out;
tran_low_t temp_in[16], temp_out[16];
const high_transform_2d ht = HIGH_IHT_16[tx_type];
const highbd_transform_2d ht = HIGH_IHT_16[tx_type];
uint16_t *dest = CONVERT_TO_SHORTPTR(dest8);
// Rows
@ -2314,8 +2314,8 @@ void vp9_high_iht16x16_256_add_c(const tran_low_t *input, uint8_t *dest8,
}
}
void vp9_high_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
void vp9_highbd_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
tran_low_t out[16 * 16] = { 0 };
tran_low_t *outptr = out;
int i, j;
@ -2342,8 +2342,8 @@ void vp9_high_idct16x16_10_add_c(const tran_low_t *input, uint8_t *dest8,
}
}
void vp9_high_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
void vp9_highbd_idct16x16_1_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
int i, j;
tran_high_t a1;
tran_low_t out = WRAPLOW(dct_const_round_shift(input[0] * cospi_16_64), bd);
@ -2726,8 +2726,8 @@ static void highbd_idct32(const tran_low_t *input, tran_low_t *output, int bd) {
output[31] = WRAPLOW(step1[0] - step1[31], bd);
}
void vp9_high_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
void vp9_highbd_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
tran_low_t out[32 * 32];
tran_low_t *outptr = out;
int i, j;
@ -2766,8 +2766,8 @@ void vp9_high_idct32x32_1024_add_c(const tran_low_t *input, uint8_t *dest8,
}
}
void vp9_high_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
void vp9_highbd_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
tran_low_t out[32 * 32] = {0};
tran_low_t *outptr = out;
int i, j;
@ -2793,8 +2793,8 @@ void vp9_high_idct32x32_34_add_c(const tran_low_t *input, uint8_t *dest8,
}
}
void vp9_high_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
void vp9_highbd_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest8,
int stride, int bd) {
int i, j;
int a1;
uint16_t *dest = CONVERT_TO_SHORTPTR(dest8);
@ -2811,25 +2811,25 @@ void vp9_high_idct32x32_1_add_c(const tran_low_t *input, uint8_t *dest8,
}
// idct
void vp9_high_idct4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd) {
void vp9_highbd_idct4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd) {
if (eob > 1)
vp9_high_idct4x4_16_add(input, dest, stride, bd);
vp9_highbd_idct4x4_16_add(input, dest, stride, bd);
else
vp9_high_idct4x4_1_add(input, dest, stride, bd);
vp9_highbd_idct4x4_1_add(input, dest, stride, bd);
}
void vp9_high_iwht4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd) {
void vp9_highbd_iwht4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd) {
if (eob > 1)
vp9_high_iwht4x4_16_add(input, dest, stride, bd);
vp9_highbd_iwht4x4_16_add(input, dest, stride, bd);
else
vp9_high_iwht4x4_1_add(input, dest, stride, bd);
vp9_highbd_iwht4x4_1_add(input, dest, stride, bd);
}
void vp9_high_idct8x8_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd) {
void vp9_highbd_idct8x8_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd) {
// If dc is 1, then input[0] is the reconstructed value, do not need
// dequantization. Also, when dc is 1, dc is counted in eobs, namely eobs >=1.
@ -2839,64 +2839,64 @@ void vp9_high_idct8x8_add(const tran_low_t *input, uint8_t *dest, int stride,
// Combine that with code here.
// DC only DCT coefficient
if (eob == 1) {
vp9_high_idct8x8_1_add(input, dest, stride, bd);
vp9_highbd_idct8x8_1_add(input, dest, stride, bd);
} else if (eob <= 10) {
vp9_high_idct8x8_10_add(input, dest, stride, bd);
vp9_highbd_idct8x8_10_add(input, dest, stride, bd);
} else {
vp9_high_idct8x8_64_add(input, dest, stride, bd);
vp9_highbd_idct8x8_64_add(input, dest, stride, bd);
}
}
void vp9_high_idct16x16_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd) {
void vp9_highbd_idct16x16_add(const tran_low_t *input, uint8_t *dest,
int stride, int eob, int bd) {
// The calculation can be simplified if there are not many non-zero dct
// coefficients. Use eobs to separate different cases.
// DC only DCT coefficient.
if (eob == 1) {
vp9_high_idct16x16_1_add(input, dest, stride, bd);
vp9_highbd_idct16x16_1_add(input, dest, stride, bd);
} else if (eob <= 10) {
vp9_high_idct16x16_10_add(input, dest, stride, bd);
vp9_highbd_idct16x16_10_add(input, dest, stride, bd);
} else {
vp9_high_idct16x16_256_add(input, dest, stride, bd);
vp9_highbd_idct16x16_256_add(input, dest, stride, bd);
}
}
void vp9_high_idct32x32_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd) {
void vp9_highbd_idct32x32_add(const tran_low_t *input, uint8_t *dest,
int stride, int eob, int bd) {
// Non-zero coeff only in upper-left 8x8
if (eob == 1) {
vp9_high_idct32x32_1_add(input, dest, stride, bd);
vp9_highbd_idct32x32_1_add(input, dest, stride, bd);
} else if (eob <= 34) {
vp9_high_idct32x32_34_add(input, dest, stride, bd);
vp9_highbd_idct32x32_34_add(input, dest, stride, bd);
} else {
vp9_high_idct32x32_1024_add(input, dest, stride, bd);
vp9_highbd_idct32x32_1024_add(input, dest, stride, bd);
}
}
// iht
void vp9_high_iht4x4_add(TX_TYPE tx_type, const tran_low_t *input,
uint8_t *dest, int stride, int eob, int bd) {
void vp9_highbd_iht4x4_add(TX_TYPE tx_type, const tran_low_t *input,
uint8_t *dest, int stride, int eob, int bd) {
if (tx_type == DCT_DCT)
vp9_high_idct4x4_add(input, dest, stride, eob, bd);
vp9_highbd_idct4x4_add(input, dest, stride, eob, bd);
else
vp9_high_iht4x4_16_add(input, dest, stride, tx_type, bd);
vp9_highbd_iht4x4_16_add(input, dest, stride, tx_type, bd);
}
void vp9_high_iht8x8_add(TX_TYPE tx_type, const tran_low_t *input,
uint8_t *dest, int stride, int eob, int bd) {
void vp9_highbd_iht8x8_add(TX_TYPE tx_type, const tran_low_t *input,
uint8_t *dest, int stride, int eob, int bd) {
if (tx_type == DCT_DCT) {
vp9_high_idct8x8_add(input, dest, stride, eob, bd);
vp9_highbd_idct8x8_add(input, dest, stride, eob, bd);
} else {
vp9_high_iht8x8_64_add(input, dest, stride, tx_type, bd);
vp9_highbd_iht8x8_64_add(input, dest, stride, tx_type, bd);
}
}
void vp9_high_iht16x16_add(TX_TYPE tx_type, const tran_low_t *input,
void vp9_highbd_iht16x16_add(TX_TYPE tx_type, const tran_low_t *input,
uint8_t *dest, int stride, int eob, int bd) {
if (tx_type == DCT_DCT) {
vp9_high_idct16x16_add(input, dest, stride, eob, bd);
vp9_highbd_idct16x16_add(input, dest, stride, eob, bd);
} else {
vp9_high_iht16x16_256_add(input, dest, stride, tx_type, bd);
vp9_highbd_iht16x16_256_add(input, dest, stride, tx_type, bd);
}
}
#endif // CONFIG_VP9_HIGHBITDEPTH

32
vp9/common/vp9_idct.h
Просмотреть файл

@ -109,11 +109,11 @@ typedef struct {
} transform_2d;
#if CONFIG_VP9_HIGHBITDEPTH
typedef void (*high_transform_1d)(const tran_low_t*, tran_low_t*, int bd);
typedef void (*highbd_transform_1d)(const tran_low_t*, tran_low_t*, int bd);
typedef struct {
high_transform_1d cols, rows; // vertical and horizontal
} high_transform_2d;
highbd_transform_1d cols, rows; // vertical and horizontal
} highbd_transform_2d;
#endif // CONFIG_VP9_HIGHBITDEPTH
void vp9_iwht4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
@ -135,22 +135,22 @@ void vp9_iht16x16_add(TX_TYPE tx_type, const tran_low_t *input, uint8_t *dest,
int stride, int eob);
#if CONFIG_VP9_HIGHBITDEPTH
void vp9_high_iwht4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd);
void vp9_high_idct4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd);
void vp9_high_idct8x8_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd);
void vp9_high_idct16x16_add(const tran_low_t *input, uint8_t *dest, int stride,
void vp9_highbd_iwht4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd);
void vp9_high_idct32x32_add(const tran_low_t *input, uint8_t *dest, int stride,
void vp9_highbd_idct4x4_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd);
void vp9_high_iht4x4_add(TX_TYPE tx_type, const tran_low_t *input,
uint8_t *dest, int stride, int eob, int bd);
void vp9_high_iht8x8_add(TX_TYPE tx_type, const tran_low_t *input,
uint8_t *dest, int stride, int eob, int bd);
void vp9_high_iht16x16_add(TX_TYPE tx_type, const tran_low_t *input,
void vp9_highbd_idct8x8_add(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd);
void vp9_highbd_idct16x16_add(const tran_low_t *input, uint8_t *dest,
int stride, int eob, int bd);
void vp9_highbd_idct32x32_add(const tran_low_t *input, uint8_t *dest,
int stride, int eob, int bd);
void vp9_highbd_iht4x4_add(TX_TYPE tx_type, const tran_low_t *input,
uint8_t *dest, int stride, int eob, int bd);
void vp9_highbd_iht8x8_add(TX_TYPE tx_type, const tran_low_t *input,
uint8_t *dest, int stride, int eob, int bd);
void vp9_highbd_iht16x16_add(TX_TYPE tx_type, const tran_low_t *input,
uint8_t *dest, int stride, int eob, int bd);
#endif // CONFIG_VP9_HIGHBITDEPTH
#ifdef __cplusplus
} // extern "C"

150
vp9/common/vp9_loopfilter.c
Просмотреть файл

@ -393,14 +393,14 @@ static void filter_selectively_vert_row2(PLANE_TYPE plane_type,
}
#if CONFIG_VP9_HIGHBITDEPTH
static void high_filter_selectively_vert_row2(PLANE_TYPE plane_type,
uint16_t *s, int pitch,
unsigned int mask_16x16_l,
unsigned int mask_8x8_l,
unsigned int mask_4x4_l,
unsigned int mask_4x4_int_l,
const loop_filter_info_n *lfi_n,
const uint8_t *lfl, int bd) {
static void highbd_filter_selectively_vert_row2(PLANE_TYPE plane_type,
uint16_t *s, int pitch,
unsigned int mask_16x16_l,
unsigned int mask_8x8_l,
unsigned int mask_4x4_l,
unsigned int mask_4x4_int_l,
const loop_filter_info_n *lfi_n,
const uint8_t *lfl, int bd) {
const int mask_shift = plane_type ? 4 : 8;
const int mask_cutoff = plane_type ? 0xf : 0xff;
const int lfl_forward = plane_type ? 4 : 8;
@ -590,13 +590,13 @@ static void filter_selectively_horiz(uint8_t *s, int pitch,
}
#if CONFIG_VP9_HIGHBITDEPTH
static void high_filter_selectively_horiz(uint16_t *s, int pitch,
unsigned int mask_16x16,
unsigned int mask_8x8,
unsigned int mask_4x4,
unsigned int mask_4x4_int,
const loop_filter_info_n *lfi_n,
const uint8_t *lfl, int bd) {
static void highbd_filter_selectively_horiz(uint16_t *s, int pitch,
unsigned int mask_16x16,
unsigned int mask_8x8,
unsigned int mask_4x4,
unsigned int mask_4x4_int,
const loop_filter_info_n *lfi_n,
const uint8_t *lfl, int bd) {
unsigned int mask;
int count;
@ -1111,13 +1111,13 @@ static void filter_selectively_vert(uint8_t *s, int pitch,
}
#if CONFIG_VP9_HIGHBITDEPTH
static void high_filter_selectively_vert(uint16_t *s, int pitch,
unsigned int mask_16x16,
unsigned int mask_8x8,
unsigned int mask_4x4,
unsigned int mask_4x4_int,
const loop_filter_info_n *lfi_n,
const uint8_t *lfl, int bd) {
static void highbd_filter_selectively_vert(uint16_t *s, int pitch,
unsigned int mask_16x16,
unsigned int mask_8x8,
unsigned int mask_4x4,
unsigned int mask_4x4_int,
const loop_filter_info_n *lfi_n,
const uint8_t *lfl, int bd) {
unsigned int mask;
for (mask = mask_16x16 | mask_8x8 | mask_4x4 | mask_4x4_int;
@ -1249,14 +1249,14 @@ static void filter_block_plane_non420(VP9_COMMON *cm,
border_mask = ~(mi_col == 0);
#if CONFIG_VP9_HIGHBITDEPTH
if (cm->use_highbitdepth) {
high_filter_selectively_vert(CONVERT_TO_SHORTPTR(dst->buf),
dst->stride,
mask_16x16_c & border_mask,
mask_8x8_c & border_mask,
mask_4x4_c & border_mask,
mask_4x4_int[r],
&cm->lf_info, &lfl[r << 3],
(int)cm->bit_depth);
highbd_filter_selectively_vert(CONVERT_TO_SHORTPTR(dst->buf),
dst->stride,
mask_16x16_c & border_mask,
mask_8x8_c & border_mask,
mask_4x4_c & border_mask,
mask_4x4_int[r],
&cm->lf_info, &lfl[r << 3],
(int)cm->bit_depth);
} else {
filter_selectively_vert(dst->buf, dst->stride,
mask_16x16_c & border_mask,
@ -1298,14 +1298,14 @@ static void filter_block_plane_non420(VP9_COMMON *cm,
}
#if CONFIG_VP9_HIGHBITDEPTH
if (cm->use_highbitdepth) {
high_filter_selectively_horiz(CONVERT_TO_SHORTPTR(dst->buf),
dst->stride,
mask_16x16_r,
mask_8x8_r,
mask_4x4_r,
mask_4x4_int_r,
&cm->lf_info, &lfl[r << 3],
(int)cm->bit_depth);
highbd_filter_selectively_horiz(CONVERT_TO_SHORTPTR(dst->buf),
dst->stride,
mask_16x16_r,
mask_8x8_r,
mask_4x4_r,
mask_4x4_int_r,
&cm->lf_info, &lfl[r << 3],
(int)cm->bit_depth);
} else {
filter_selectively_horiz(dst->buf, dst->stride,
mask_16x16_r,
@ -1350,15 +1350,15 @@ void vp9_filter_block_plane(VP9_COMMON *const cm,
// Disable filtering on the leftmost column.
#if CONFIG_VP9_HIGHBITDEPTH
if (cm->use_highbitdepth) {
high_filter_selectively_vert_row2(plane->plane_type,
CONVERT_TO_SHORTPTR(dst->buf),
dst->stride,
mask_16x16_l,
mask_8x8_l,
mask_4x4_l,
mask_4x4_int_l,
&cm->lf_info, &lfm->lfl_y[r << 3],
(int)cm->bit_depth);
highbd_filter_selectively_vert_row2(plane->plane_type,
CONVERT_TO_SHORTPTR(dst->buf),
dst->stride,
mask_16x16_l,
mask_8x8_l,
mask_4x4_l,
mask_4x4_int_l,
&cm->lf_info, &lfm->lfl_y[r << 3],
(int)cm->bit_depth);
} else {
filter_selectively_vert_row2(plane->plane_type,
dst->buf, dst->stride,
@ -1409,15 +1409,15 @@ void vp9_filter_block_plane(VP9_COMMON *const cm,
#if CONFIG_VP9_HIGHBITDEPTH
if (cm->use_highbitdepth) {
high_filter_selectively_horiz(CONVERT_TO_SHORTPTR(dst->buf),
dst->stride,
mask_16x16_r,
mask_8x8_r,
mask_4x4_r,
mask_4x4_int & 0xff,
&cm->lf_info,
&lfm->lfl_y[r << 3],
(int)cm->bit_depth);
highbd_filter_selectively_horiz(CONVERT_TO_SHORTPTR(dst->buf),
dst->stride,
mask_16x16_r,
mask_8x8_r,
mask_4x4_r,
mask_4x4_int & 0xff,
&cm->lf_info,
&lfm->lfl_y[r << 3],
(int)cm->bit_depth);
} else {
filter_selectively_horiz(dst->buf, dst->stride,
mask_16x16_r,
@ -1468,16 +1468,16 @@ void vp9_filter_block_plane(VP9_COMMON *const cm,
// Disable filtering on the leftmost column.
#if CONFIG_VP9_HIGHBITDEPTH
if (cm->use_highbitdepth) {
high_filter_selectively_vert_row2(plane->plane_type,
CONVERT_TO_SHORTPTR(dst->buf),
dst->stride,
mask_16x16_l,
mask_8x8_l,
mask_4x4_l,
mask_4x4_int_l,
&cm->lf_info,
&lfm->lfl_uv[r << 1],
(int)cm->bit_depth);
highbd_filter_selectively_vert_row2(plane->plane_type,
CONVERT_TO_SHORTPTR(dst->buf),
dst->stride,
mask_16x16_l,
mask_8x8_l,
mask_4x4_l,
mask_4x4_int_l,
&cm->lf_info,
&lfm->lfl_uv[r << 1],
(int)cm->bit_depth);
} else {
filter_selectively_vert_row2(plane->plane_type,
dst->buf, dst->stride,
@ -1534,15 +1534,15 @@ void vp9_filter_block_plane(VP9_COMMON *const cm,
#if CONFIG_VP9_HIGHBITDEPTH
if (cm->use_highbitdepth) {
high_filter_selectively_horiz(CONVERT_TO_SHORTPTR(dst->buf),
dst->stride,
mask_16x16_r,
mask_8x8_r,
mask_4x4_r,
mask_4x4_int_r,
&cm->lf_info,
&lfm->lfl_uv[r << 1],
(int)cm->bit_depth);
highbd_filter_selectively_horiz(CONVERT_TO_SHORTPTR(dst->buf),
dst->stride,
mask_16x16_r,
mask_8x8_r,
mask_4x4_r,
mask_4x4_int_r,
&cm->lf_info,
&lfm->lfl_uv[r << 1],
(int)cm->bit_depth);
} else {
filter_selectively_horiz(dst->buf, dst->stride,
mask_16x16_r,

164
vp9/common/vp9_loopfilter_filters.c
Просмотреть файл

@ -354,11 +354,11 @@ void vp9_lpf_vertical_16_dual_c(uint8_t *s, int p, const uint8_t *blimit,
#if CONFIG_VP9_HIGHBITDEPTH
// Should we apply any filter at all: 11111111 yes, 00000000 no ?
static INLINE int8_t high_filter_mask(uint8_t limit, uint8_t blimit,
uint16_t p3, uint16_t p2,
uint16_t p1, uint16_t p0,
uint16_t q0, uint16_t q1,
uint16_t q2, uint16_t q3, int bd) {
static INLINE int8_t highbd_filter_mask(uint8_t limit, uint8_t blimit,
uint16_t p3, uint16_t p2,
uint16_t p1, uint16_t p0,
uint16_t q0, uint16_t q1,
uint16_t q2, uint16_t q3, int bd) {
int8_t mask = 0;
int16_t limit16 = (uint16_t)limit << (bd - 8);
int16_t blimit16 = (uint16_t)blimit << (bd - 8);
@ -372,11 +372,11 @@ static INLINE int8_t high_filter_mask(uint8_t limit, uint8_t blimit,
return ~mask;
}
static INLINE int8_t high_flat_mask4(uint8_t thresh,
uint16_t p3, uint16_t p2,
uint16_t p1, uint16_t p0,
uint16_t q0, uint16_t q1,
uint16_t q2, uint16_t q3, int bd) {
static INLINE int8_t highbd_flat_mask4(uint8_t thresh,
uint16_t p3, uint16_t p2,
uint16_t p1, uint16_t p0,
uint16_t q0, uint16_t q1,
uint16_t q2, uint16_t q3, int bd) {
int8_t mask = 0;
int16_t thresh16 = (uint16_t)thresh << (bd - 8);
mask |= (abs(p1 - p0) > thresh16) * -1;
@ -388,13 +388,13 @@ static INLINE int8_t high_flat_mask4(uint8_t thresh,
return ~mask;
}
static INLINE int8_t high_flat_mask5(uint8_t thresh,
uint16_t p4, uint16_t p3,
uint16_t p2, uint16_t p1,
uint16_t p0, uint16_t q0,
uint16_t q1, uint16_t q2,
uint16_t q3, uint16_t q4, int bd) {
int8_t mask = ~high_flat_mask4(thresh, p3, p2, p1, p0, q0, q1, q2, q3, bd);
static INLINE int8_t highbd_flat_mask5(uint8_t thresh,
uint16_t p4, uint16_t p3,
uint16_t p2, uint16_t p1,
uint16_t p0, uint16_t q0,
uint16_t q1, uint16_t q2,
uint16_t q3, uint16_t q4, int bd) {
int8_t mask = ~highbd_flat_mask4(thresh, p3, p2, p1, p0, q0, q1, q2, q3, bd);
int16_t thresh16 = (uint16_t)thresh << (bd - 8);
mask |= (abs(p4 - p0) > thresh16) * -1;
mask |= (abs(q4 - q0) > thresh16) * -1;
@ -403,8 +403,8 @@ static INLINE int8_t high_flat_mask5(uint8_t thresh,
// Is there high edge variance internal edge:
// 11111111_11111111 yes, 00000000_00000000 no ?
static INLINE int16_t high_hev_mask(uint8_t thresh, uint16_t p1, uint16_t p0,
uint16_t q0, uint16_t q1, int bd) {
static INLINE int16_t highbd_hev_mask(uint8_t thresh, uint16_t p1, uint16_t p0,
uint16_t q0, uint16_t q1, int bd) {
int16_t hev = 0;
int16_t thresh16 = (uint16_t)thresh << (bd - 8);
hev |= (abs(p1 - p0) > thresh16) * -1;
@ -412,9 +412,9 @@ static INLINE int16_t high_hev_mask(uint8_t thresh, uint16_t p1, uint16_t p0,
return hev;
}
static INLINE void high_filter4(int8_t mask, uint8_t thresh, uint16_t *op1,
uint16_t *op0, uint16_t *oq0, uint16_t *oq1,
int bd) {
static INLINE void highbd_filter4(int8_t mask, uint8_t thresh, uint16_t *op1,
uint16_t *op0, uint16_t *oq0, uint16_t *oq1,
int bd) {
int16_t filter1, filter2;
// ^0x80 equivalent to subtracting 0x80 from the values to turn them
// into -128 to +127 instead of 0 to 255.
@ -423,7 +423,7 @@ static INLINE void high_filter4(int8_t mask, uint8_t thresh, uint16_t *op1,
const int16_t ps0 = (int16_t)*op0 - (0x80 << shift);
const int16_t qs0 = (int16_t)*oq0 - (0x80 << shift);
const int16_t qs1 = (int16_t)*oq1 - (0x80 << shift);
const uint16_t hev = high_hev_mask(thresh, *op1, *op0, *oq0, *oq1, bd);
const uint16_t hev = highbd_hev_mask(thresh, *op1, *op0, *oq0, *oq1, bd);
// Add outer taps if we have high edge variance.
int16_t filter = signed_char_clamp_high(ps1 - qs1, bd) & hev;
@ -463,9 +463,9 @@ void vp9_highbd_lpf_horizontal_4_c(uint16_t *s, int p /* pitch */,
const uint16_t q1 = s[1 * p];
const uint16_t q2 = s[2 * p];
const uint16_t q3 = s[3 * p];
const int8_t mask = high_filter_mask(*limit, *blimit,
p3, p2, p1, p0, q0, q1, q2, q3, bd);
high_filter4(mask, *thresh, s - 2 * p, s - 1 * p, s, s + 1 * p, bd);
const int8_t mask = highbd_filter_mask(*limit, *blimit,
p3, p2, p1, p0, q0, q1, q2, q3, bd);
highbd_filter4(mask, *thresh, s - 2 * p, s - 1 * p, s, s + 1 * p, bd);
++s;
}
}
@ -492,9 +492,9 @@ void vp9_highbd_lpf_vertical_4_c(uint16_t *s, int pitch, const uint8_t *blimit,
for (i = 0; i < 8 * count; ++i) {
const uint16_t p3 = s[-4], p2 = s[-3], p1 = s[-2], p0 = s[-1];
const uint16_t q0 = s[0], q1 = s[1], q2 = s[2], q3 = s[3];
const int8_t mask = high_filter_mask(*limit, *blimit,
p3, p2, p1, p0, q0, q1, q2, q3, bd);
high_filter4(mask, *thresh, s - 2, s - 1, s, s + 1, bd);
const int8_t mask = highbd_filter_mask(*limit, *blimit,
p3, p2, p1, p0, q0, q1, q2, q3, bd);
highbd_filter4(mask, *thresh, s - 2, s - 1, s, s + 1, bd);
s += pitch;
}
}
@ -512,11 +512,11 @@ void vp9_highbd_lpf_vertical_4_dual_c(uint16_t *s, int pitch,
thresh1, 1, bd);
}
static INLINE void high_filter8(int8_t mask, uint8_t thresh, uint8_t flat,
uint16_t *op3, uint16_t *op2,
uint16_t *op1, uint16_t *op0,
uint16_t *oq0, uint16_t *oq1,
uint16_t *oq2, uint16_t *oq3, int bd) {
static INLINE void highbd_filter8(int8_t mask, uint8_t thresh, uint8_t flat,
uint16_t *op3, uint16_t *op2,
uint16_t *op1, uint16_t *op0,
uint16_t *oq0, uint16_t *oq1,
uint16_t *oq2, uint16_t *oq3, int bd) {
if (flat && mask) {
const uint16_t p3 = *op3, p2 = *op2, p1 = *op1, p0 = *op0;
const uint16_t q0 = *oq0, q1 = *oq1, q2 = *oq2, q3 = *oq3;
@ -529,7 +529,7 @@ static INLINE void high_filter8(int8_t mask, uint8_t thresh, uint8_t flat,
*oq1 = ROUND_POWER_OF_TWO(p1 + p0 + q0 + 2 * q1 + q2 + q3 + q3, 3);
*oq2 = ROUND_POWER_OF_TWO(p0 + q0 + q1 + 2 * q2 + q3 + q3 + q3, 3);
} else {
high_filter4(mask, thresh, op1, op0, oq0, oq1, bd);
highbd_filter4(mask, thresh, op1, op0, oq0, oq1, bd);
}
}
@ -544,10 +544,11 @@ void vp9_highbd_lpf_horizontal_8_c(uint16_t *s, int p, const uint8_t *blimit,
const uint16_t p3 = s[-4 * p], p2 = s[-3 * p], p1 = s[-2 * p], p0 = s[-p];
const uint16_t q0 = s[0 * p], q1 = s[1 * p], q2 = s[2 * p], q3 = s[3 * p];
const int8_t mask = high_filter_mask(*limit, *blimit,
const int8_t mask = highbd_filter_mask(*limit, *blimit,
p3, p2, p1, p0, q0, q1, q2, q3, bd);
const int8_t flat = high_flat_mask4(1, p3, p2, p1, p0, q0, q1, q2, q3, bd);
high_filter8(mask, *thresh, flat,
const int8_t flat = highbd_flat_mask4(1, p3, p2, p1, p0, q0, q1, q2, q3,
bd);
highbd_filter8(mask, *thresh, flat,
s - 4 * p, s - 3 * p, s - 2 * p, s - 1 * p,
s, s + 1 * p, s + 2 * p, s + 3 * p, bd);
++s;
@ -574,10 +575,11 @@ void vp9_highbd_lpf_vertical_8_c(uint16_t *s, int pitch, const uint8_t *blimit,
for (i = 0; i < 8 * count; ++i) {
const uint16_t p3 = s[-4], p2 = s[-3], p1 = s[-2], p0 = s[-1];
const uint16_t q0 = s[0], q1 = s[1], q2 = s[2], q3 = s[3];
const int8_t mask = high_filter_mask(*limit, *blimit,
p3, p2, p1, p0, q0, q1, q2, q3, bd);
const int8_t flat = high_flat_mask4(1, p3, p2, p1, p0, q0, q1, q2, q3, bd);
high_filter8(mask, *thresh, flat,
const int8_t mask = highbd_filter_mask(*limit, *blimit,
p3, p2, p1, p0, q0, q1, q2, q3, bd);
const int8_t flat = highbd_flat_mask4(1, p3, p2, p1, p0, q0, q1, q2, q3,
bd);
highbd_filter8(mask, *thresh, flat,
s - 4, s - 3, s - 2, s - 1,
s, s + 1, s + 2, s + 3,
bd);
@ -598,16 +600,16 @@ void vp9_highbd_lpf_vertical_8_dual_c(uint16_t *s, int pitch,
thresh1, 1, bd);
}
static INLINE void high_filter16(int8_t mask, uint8_t thresh,
uint8_t flat, uint8_t flat2,
uint16_t *op7, uint16_t *op6,
uint16_t *op5, uint16_t *op4,
uint16_t *op3, uint16_t *op2,
uint16_t *op1, uint16_t *op0,
uint16_t *oq0, uint16_t *oq1,
uint16_t *oq2, uint16_t *oq3,
uint16_t *oq4, uint16_t *oq5,
uint16_t *oq6, uint16_t *oq7, int bd) {
static INLINE void highbd_filter16(int8_t mask, uint8_t thresh,
uint8_t flat, uint8_t flat2,
uint16_t *op7, uint16_t *op6,
uint16_t *op5, uint16_t *op4,
uint16_t *op3, uint16_t *op2,
uint16_t *op1, uint16_t *op0,
uint16_t *oq0, uint16_t *oq1,
uint16_t *oq2, uint16_t *oq3,
uint16_t *oq4, uint16_t *oq5,
uint16_t *oq6, uint16_t *oq7, int bd) {
if (flat2 && flat && mask) {
const uint16_t p7 = *op7;
const uint16_t p6 = *op6;
@ -656,8 +658,8 @@ static INLINE void high_filter16(int8_t mask, uint8_t thresh,
*oq6 = ROUND_POWER_OF_TWO(p0 +
q0 + q1 + q2 + q3 + q4 + q5 + q6 * 2 + q7 * 7, 4);
} else {
high_filter8(mask, thresh, flat, op3, op2, op1, op0, oq0, oq1, oq2, oq3,
bd);
highbd_filter8(mask, thresh, flat, op3, op2, op1, op0, oq0, oq1, oq2, oq3,
bd);
}
}
@ -677,28 +679,29 @@ void vp9_highbd_lpf_horizontal_16_c(uint16_t *s, int p, const uint8_t *blimit,
const uint16_t q1 = s[1 * p];
const uint16_t q2 = s[2 * p];
const uint16_t q3 = s[3 * p];
const int8_t mask = high_filter_mask(*limit, *blimit,
p3, p2, p1, p0, q0, q1, q2, q3, bd);
const int8_t flat = high_flat_mask4(1, p3, p2, p1, p0, q0, q1, q2, q3, bd);
const int8_t flat2 = high_flat_mask5(
const int8_t mask = highbd_filter_mask(*limit, *blimit,
p3, p2, p1, p0, q0, q1, q2, q3, bd);
const int8_t flat = highbd_flat_mask4(1, p3, p2, p1, p0, q0, q1, q2, q3,
bd);
const int8_t flat2 = highbd_flat_mask5(
1, s[-8 * p], s[-7 * p], s[-6 * p], s[-5 * p], p0,
q0, s[4 * p], s[5 * p], s[6 * p], s[7 * p], bd);
high_filter16(mask, *thresh, flat, flat2,
s - 8 * p, s - 7 * p, s - 6 * p, s - 5 * p,
s - 4 * p, s - 3 * p, s - 2 * p, s - 1 * p,
s, s + 1 * p, s + 2 * p, s + 3 * p,
s + 4 * p, s + 5 * p, s + 6 * p, s + 7 * p,
bd);
highbd_filter16(mask, *thresh, flat, flat2,
s - 8 * p, s - 7 * p, s - 6 * p, s - 5 * p,
s - 4 * p, s - 3 * p, s - 2 * p, s - 1 * p,
s, s + 1 * p, s + 2 * p, s + 3 * p,
s + 4 * p, s + 5 * p, s + 6 * p, s + 7 * p,
bd);
++s;
}
}
static void high_mb_lpf_vertical_edge_w(uint16_t *s, int p,
const uint8_t *blimit,
const uint8_t *limit,
const uint8_t *thresh,
int count, int bd) {
static void highbd_mb_lpf_vertical_edge_w(uint16_t *s, int p,
const uint8_t *blimit,
const uint8_t *limit,
const uint8_t *thresh,
int count, int bd) {
int i;
for (i = 0; i < count; ++i) {
@ -710,16 +713,17 @@ static void high_mb_lpf_vertical_edge_w(uint16_t *s, int p,
const uint16_t q1 = s[1];
const uint16_t q2 = s[2];
const uint16_t q3 = s[3];
const int8_t mask = high_filter_mask(*limit, *blimit,
p3, p2, p1, p0, q0, q1, q2, q3, bd);
const int8_t flat = high_flat_mask4(1, p3, p2, p1, p0, q0, q1, q2, q3, bd);
const int8_t flat2 = high_flat_mask5(1, s[-8], s[-7], s[-6], s[-5], p0,
q0, s[4], s[5], s[6], s[7], bd);
const int8_t mask = highbd_filter_mask(*limit, *blimit,
p3, p2, p1, p0, q0, q1, q2, q3, bd);
const int8_t flat = highbd_flat_mask4(1, p3, p2, p1, p0, q0, q1, q2, q3,
bd);
const int8_t flat2 = highbd_flat_mask5(1, s[-8], s[-7], s[-6], s[-5], p0,
q0, s[4], s[5], s[6], s[7], bd);
high_filter16(mask, *thresh, flat, flat2,
s - 8, s - 7, s - 6, s - 5, s - 4, s - 3, s - 2, s - 1,
s, s + 1, s + 2, s + 3, s + 4, s + 5, s + 6, s + 7,
bd);
highbd_filter16(mask, *thresh, flat, flat2,
s - 8, s - 7, s - 6, s - 5, s - 4, s - 3, s - 2, s - 1,
s, s + 1, s + 2, s + 3, s + 4, s + 5, s + 6, s + 7,
bd);
s += p;
}
}
@ -727,7 +731,7 @@ static void high_mb_lpf_vertical_edge_w(uint16_t *s, int p,
void vp9_highbd_lpf_vertical_16_c(uint16_t *s, int p, const uint8_t *blimit,
const uint8_t *limit, const uint8_t *thresh,
int bd) {
high_mb_lpf_vertical_edge_w(s, p, blimit, limit, thresh, 8, bd);
highbd_mb_lpf_vertical_edge_w(s, p, blimit, limit, thresh, 8, bd);
}
void vp9_highbd_lpf_vertical_16_dual_c(uint16_t *s, int p,
@ -735,6 +739,6 @@ void vp9_highbd_lpf_vertical_16_dual_c(uint16_t *s, int p,
const uint8_t *limit,
const uint8_t *thresh,
int bd) {
high_mb_lpf_vertical_edge_w(s, p, blimit, limit, thresh, 16, bd);
highbd_mb_lpf_vertical_edge_w(s, p, blimit, limit, thresh, 16, bd);
}
#endif // CONFIG_VP9_HIGHBITDEPTH

18
vp9/common/vp9_reconinter.c
Просмотреть файл

@ -153,19 +153,19 @@ static void high_inter_predictor(const uint8_t *src, int src_stride,
int w, int h, int ref,
const InterpKernel *kernel,
int xs, int ys, int bd) {
sf->high_predict[subpel_x != 0][subpel_y != 0][ref](
sf->highbd_predict[subpel_x != 0][subpel_y != 0][ref](
src, src_stride, dst, dst_stride,
kernel[subpel_x], xs, kernel[subpel_y], ys, w, h, bd);
}
void vp9_high_build_inter_predictor(const uint8_t *src, int src_stride,
uint8_t *dst, int dst_stride,
const MV *src_mv,
const struct scale_factors *sf,
int w, int h, int ref,
const InterpKernel *kernel,
enum mv_precision precision,
int x, int y, int bd) {
void vp9_highbd_build_inter_predictor(const uint8_t *src, int src_stride,
uint8_t *dst, int dst_stride,
const MV *src_mv,
const struct scale_factors *sf,
int w, int h, int ref,
const InterpKernel *kernel,
enum mv_precision precision,
int x, int y, int bd) {
const int is_q4 = precision == MV_PRECISION_Q4;
const MV mv_q4 = { is_q4 ? src_mv->row : src_mv->row * 2,
is_q4 ? src_mv->col : src_mv->col * 2 };

16
vp9/common/vp9_reconinter.h
Просмотреть файл

@ -40,14 +40,14 @@ void vp9_build_inter_predictor(const uint8_t *src, int src_stride,
int x, int y);
#if CONFIG_VP9_HIGHBITDEPTH
void vp9_high_build_inter_predictor(const uint8_t *src, int src_stride,
uint8_t *dst, int dst_stride,
const MV *mv_q3,
const struct scale_factors *sf,
int w, int h, int do_avg,
const InterpKernel *kernel,
enum mv_precision precision,
int x, int y, int bd);
void vp9_highbd_build_inter_predictor(const uint8_t *src, int src_stride,
uint8_t *dst, int dst_stride,
const MV *mv_q3,
const struct scale_factors *sf,
int w, int h, int do_avg,
const InterpKernel *kernel,
enum mv_precision precision,
int x, int y, int bd);
#endif
static INLINE int scaled_buffer_offset(int x_offset, int y_offset, int stride,

118
vp9/common/vp9_reconintra.c
Просмотреть файл

@ -41,11 +41,11 @@ const TX_TYPE intra_mode_to_tx_type_lookup[INTRA_MODES] = {
}
#if CONFIG_VP9_HIGHBITDEPTH
#define intra_pred_high_sized(type, size) \
void vp9_high_##type##_predictor_##size##x##size##_c( \
#define intra_pred_highbd_sized(type, size) \
void vp9_highbd_##type##_predictor_##size##x##size##_c( \
uint16_t *dst, ptrdiff_t stride, const uint16_t *above, \
const uint16_t *left, int bd) { \
high_##type##_predictor(dst, stride, size, above, left, bd); \
highbd_##type##_predictor(dst, stride, size, above, left, bd); \
}
#define intra_pred_allsizes(type) \
@ -53,10 +53,10 @@ const TX_TYPE intra_mode_to_tx_type_lookup[INTRA_MODES] = {
intra_pred_sized(type, 8) \
intra_pred_sized(type, 16) \
intra_pred_sized(type, 32) \
intra_pred_high_sized(type, 4) \
intra_pred_high_sized(type, 8) \
intra_pred_high_sized(type, 16) \
intra_pred_high_sized(type, 32)
intra_pred_highbd_sized(type, 4) \
intra_pred_highbd_sized(type, 8) \
intra_pred_highbd_sized(type, 16) \
intra_pred_highbd_sized(type, 32)
#else
@ -68,9 +68,9 @@ const TX_TYPE intra_mode_to_tx_type_lookup[INTRA_MODES] = {
#endif // CONFIG_VP9_HIGHBITDEPTH
#if CONFIG_VP9_HIGHBITDEPTH
static INLINE void high_d207_predictor(uint16_t *dst, ptrdiff_t stride, int bs,
const uint16_t *above,
const uint16_t *left, int bd) {
static INLINE void highbd_d207_predictor(uint16_t *dst, ptrdiff_t stride,
int bs, const uint16_t *above,
const uint16_t *left, int bd) {
int r, c;
(void) above;
(void) bd;
@ -102,9 +102,9 @@ static INLINE void high_d207_predictor(uint16_t *dst, ptrdiff_t stride, int bs,
}
}
static INLINE void high_d63_predictor(uint16_t *dst, ptrdiff_t stride, int bs,
const uint16_t *above,
const uint16_t *left, int bd) {
static INLINE void highbd_d63_predictor(uint16_t *dst, ptrdiff_t stride,
int bs, const uint16_t *above,
const uint16_t *left, int bd) {
int r, c;
(void) left;
(void) bd;
@ -120,9 +120,9 @@ static INLINE void high_d63_predictor(uint16_t *dst, ptrdiff_t stride, int bs,
}
}
static INLINE void high_d45_predictor(uint16_t *dst, ptrdiff_t stride, int bs,
const uint16_t *above,
const uint16_t *left, int bd) {
static INLINE void highbd_d45_predictor(uint16_t *dst, ptrdiff_t stride, int bs,
const uint16_t *above,
const uint16_t *left, int bd) {
int r, c;
(void) left;
(void) bd;
@ -137,9 +137,9 @@ static INLINE void high_d45_predictor(uint16_t *dst, ptrdiff_t stride, int bs,
}
}
static INLINE void high_d117_predictor(uint16_t *dst, ptrdiff_t stride,
int bs, const uint16_t *above,
const uint16_t *left, int bd) {
static INLINE void highbd_d117_predictor(uint16_t *dst, ptrdiff_t stride,
int bs, const uint16_t *above,
const uint16_t *left, int bd) {
int r, c;
(void) bd;
@ -168,9 +168,9 @@ static INLINE void high_d117_predictor(uint16_t *dst, ptrdiff_t stride,
}
}
static INLINE void high_d135_predictor(uint16_t *dst, ptrdiff_t stride, int bs,
const uint16_t *above,
const uint16_t *left, int bd) {
static INLINE void highbd_d135_predictor(uint16_t *dst, ptrdiff_t stride,
int bs, const uint16_t *above,
const uint16_t *left, int bd) {
int r, c;
(void) bd;
dst[0] = ROUND_POWER_OF_TWO(left[0] + above[-1] * 2 + above[0], 2);
@ -190,9 +190,9 @@ static INLINE void high_d135_predictor(uint16_t *dst, ptrdiff_t stride, int bs,
}
}
static INLINE void high_d153_predictor(uint16_t *dst, ptrdiff_t stride, int bs,
const uint16_t *above,
const uint16_t *left, int bd) {
static INLINE void highbd_d153_predictor(uint16_t *dst, ptrdiff_t stride,
int bs, const uint16_t *above,
const uint16_t *left, int bd) {
int r, c;
(void) bd;
dst[0] = ROUND_POWER_OF_TWO(above[-1] + left[0], 1);
@ -218,9 +218,9 @@ static INLINE void high_d153_predictor(uint16_t *dst, ptrdiff_t stride, int bs,
}
}
static INLINE void high_v_predictor(uint16_t *dst, ptrdiff_t stride, int bs,
const uint16_t *above,
const uint16_t *left, int bd) {
static INLINE void highbd_v_predictor(uint16_t *dst, ptrdiff_t stride,
int bs, const uint16_t *above,
const uint16_t *left, int bd) {
int r;
(void) left;
(void) bd;
@ -230,9 +230,9 @@ static INLINE void high_v_predictor(uint16_t *dst, ptrdiff_t stride, int bs,
}
}
static INLINE void high_h_predictor(uint16_t *dst, ptrdiff_t stride, int bs,
const uint16_t *above, const uint16_t *left,
int bd) {
static INLINE void highbd_h_predictor(uint16_t *dst, ptrdiff_t stride,
int bs, const uint16_t *above,
const uint16_t *left, int bd) {
int r;
(void) above;
(void) bd;
@ -242,9 +242,9 @@ static INLINE void high_h_predictor(uint16_t *dst, ptrdiff_t stride, int bs,
}
}
static INLINE void high_tm_predictor(uint16_t *dst, ptrdiff_t stride, int bs,
const uint16_t *above,
const uint16_t *left, int bd) {
static INLINE void highbd_tm_predictor(uint16_t *dst, ptrdiff_t stride,
int bs, const uint16_t *above,
const uint16_t *left, int bd) {
int r, c;
int ytop_left = above[-1];
(void) bd;
@ -256,9 +256,9 @@ static INLINE void high_tm_predictor(uint16_t *dst, ptrdiff_t stride, int bs,
}
}
static INLINE void high_dc_128_predictor(uint16_t *dst, ptrdiff_t stride,
int bs, const uint16_t *above,
const uint16_t *left, int bd) {
static INLINE void highbd_dc_128_predictor(uint16_t *dst, ptrdiff_t stride,
int bs, const uint16_t *above,
const uint16_t *left, int bd) {
int r;
(void) above;
(void) left;
@ -269,9 +269,9 @@ static INLINE void high_dc_128_predictor(uint16_t *dst, ptrdiff_t stride,
}
}
static INLINE void high_dc_left_predictor(uint16_t *dst, ptrdiff_t stride,
int bs, const uint16_t *above,
const uint16_t *left, int bd) {
static INLINE void highbd_dc_left_predictor(uint16_t *dst, ptrdiff_t stride,
int bs, const uint16_t *above,
const uint16_t *left, int bd) {
int i, r, expected_dc, sum = 0;
(void) above;
(void) bd;
@ -286,9 +286,9 @@ static INLINE void high_dc_left_predictor(uint16_t *dst, ptrdiff_t stride,
}
}
static INLINE void high_dc_top_predictor(uint16_t *dst, ptrdiff_t stride,
int bs, const uint16_t *above,
const uint16_t *left, int bd) {
static INLINE void highbd_dc_top_predictor(uint16_t *dst, ptrdiff_t stride,
int bs, const uint16_t *above,
const uint16_t *left, int bd) {
int i, r, expected_dc, sum = 0;
(void) left;
(void) bd;
@ -303,9 +303,9 @@ static INLINE void high_dc_top_predictor(uint16_t *dst, ptrdiff_t stride,
}
}
static INLINE void high_dc_predictor(uint16_t *dst, ptrdiff_t stride,
int bs, const uint16_t *above,
const uint16_t *left, int bd) {
static INLINE void highbd_dc_predictor(uint16_t *dst, ptrdiff_t stride,
int bs, const uint16_t *above,
const uint16_t *left, int bd) {
int i, r, expected_dc, sum = 0;
const int count = 2 * bs;
(void) bd;
@ -602,20 +602,20 @@ void vp9_init_intra_predictors() {
INIT_ALL_SIZES(dc_pred[1][1], dc);
#if CONFIG_VP9_HIGHBITDEPTH
INIT_ALL_SIZES(pred_high[V_PRED], high_v);
INIT_ALL_SIZES(pred_high[H_PRED], high_h);
INIT_ALL_SIZES(pred_high[D207_PRED], high_d207);
INIT_ALL_SIZES(pred_high[D45_PRED], high_d45);
INIT_ALL_SIZES(pred_high[D63_PRED], high_d63);
INIT_ALL_SIZES(pred_high[D117_PRED], high_d117);
INIT_ALL_SIZES(pred_high[D135_PRED], high_d135);
INIT_ALL_SIZES(pred_high[D153_PRED], high_d153);
INIT_ALL_SIZES(pred_high[TM_PRED], high_tm);
INIT_ALL_SIZES(pred_high[V_PRED], highbd_v);
INIT_ALL_SIZES(pred_high[H_PRED], highbd_h);
INIT_ALL_SIZES(pred_high[D207_PRED], highbd_d207);
INIT_ALL_SIZES(pred_high[D45_PRED], highbd_d45);
INIT_ALL_SIZES(pred_high[D63_PRED], highbd_d63);
INIT_ALL_SIZES(pred_high[D117_PRED], highbd_d117);
INIT_ALL_SIZES(pred_high[D135_PRED], highbd_d135);
INIT_ALL_SIZES(pred_high[D153_PRED], highbd_d153);
INIT_ALL_SIZES(pred_high[TM_PRED], highbd_tm);
INIT_ALL_SIZES(dc_pred_high[0][0], high_dc_128);
INIT_ALL_SIZES(dc_pred_high[0][1], high_dc_top);
INIT_ALL_SIZES(dc_pred_high[1][0], high_dc_left);
INIT_ALL_SIZES(dc_pred_high[1][1], high_dc);
INIT_ALL_SIZES(dc_pred_high[0][0], highbd_dc_128);
INIT_ALL_SIZES(dc_pred_high[0][1], highbd_dc_top);
INIT_ALL_SIZES(dc_pred_high[1][0], highbd_dc_left);
INIT_ALL_SIZES(dc_pred_high[1][1], highbd_dc);
#endif // CONFIG_VP9_HIGHBITDEPTH
#undef intra_pred_allsizes

1136
vp9/common/vp9_rtcd_defs.pl
Просмотреть файл

Разница между файлами не показана из-за своего большого размера Загрузить разницу

56
vp9/common/vp9_scale.c
Просмотреть файл

@ -47,7 +47,7 @@ MV32 vp9_scale_mv(const MV *mv, int x, int y, const struct scale_factors *sf) {
void vp9_setup_scale_factors_for_frame(struct scale_factors *sf,
int other_w, int other_h,
int this_w, int this_h,
int use_high) {
int use_highbd) {
#else
void vp9_setup_scale_factors_for_frame(struct scale_factors *sf,
int other_w, int other_h,
@ -119,47 +119,47 @@ void vp9_setup_scale_factors_for_frame(struct scale_factors *sf,
sf->predict[1][1][0] = vp9_convolve8;
sf->predict[1][1][1] = vp9_convolve8_avg;
#if CONFIG_VP9_HIGHBITDEPTH
if (use_high) {
if (use_highbd) {
if (sf->x_step_q4 == 16) {
if (sf->y_step_q4 == 16) {
// No scaling in either direction.
sf->high_predict[0][0][0] = vp9_high_convolve_copy;
sf->high_predict[0][0][1] = vp9_high_convolve_avg;
sf->high_predict[0][1][0] = vp9_high_convolve8_vert;
sf->high_predict[0][1][1] = vp9_high_convolve8_avg_vert;
sf->high_predict[1][0][0] = vp9_high_convolve8_horiz;
sf->high_predict[1][0][1] = vp9_high_convolve8_avg_horiz;
sf->highbd_predict[0][0][0] = vp9_highbd_convolve_copy;
sf->highbd_predict[0][0][1] = vp9_highbd_convolve_avg;
sf->highbd_predict[0][1][0] = vp9_highbd_convolve8_vert;
sf->highbd_predict[0][1][1] = vp9_highbd_convolve8_avg_vert;
sf->highbd_predict[1][0][0] = vp9_highbd_convolve8_horiz;
sf->highbd_predict[1][0][1] = vp9_highbd_convolve8_avg_horiz;
} else {
// No scaling in x direction. Must always scale in the y direction.
sf->high_predict[0][0][0] = vp9_high_convolve8_vert;
sf->high_predict[0][0][1] = vp9_high_convolve8_avg_vert;
sf->high_predict[0][1][0] = vp9_high_convolve8_vert;
sf->high_predict[0][1][1] = vp9_high_convolve8_avg_vert;
sf->high_predict[1][0][0] = vp9_high_convolve8;
sf->high_predict[1][0][1] = vp9_high_convolve8_avg;
sf->highbd_predict[0][0][0] = vp9_highbd_convolve8_vert;
sf->highbd_predict[0][0][1] = vp9_highbd_convolve8_avg_vert;
sf->highbd_predict[0][1][0] = vp9_highbd_convolve8_vert;
sf->highbd_predict[0][1][1] = vp9_highbd_convolve8_avg_vert;
sf->highbd_predict[1][0][0] = vp9_highbd_convolve8;
sf->highbd_predict[1][0][1] = vp9_highbd_convolve8_avg;
}
} else {
if (sf->y_step_q4 == 16) {
// No scaling in the y direction. Must always scale in the x direction.
sf->high_predict[0][0][0] = vp9_high_convolve8_horiz;
sf->high_predict[0][0][1] = vp9_high_convolve8_avg_horiz;
sf->high_predict[0][1][0] = vp9_high_convolve8;
sf->high_predict[0][1][1] = vp9_high_convolve8_avg;
sf->high_predict[1][0][0] = vp9_high_convolve8_horiz;
sf->high_predict[1][0][1] = vp9_high_convolve8_avg_horiz;
sf->highbd_predict[0][0][0] = vp9_highbd_convolve8_horiz;
sf->highbd_predict[0][0][1] = vp9_highbd_convolve8_avg_horiz;
sf->highbd_predict[0][1][0] = vp9_highbd_convolve8;
sf->highbd_predict[0][1][1] = vp9_highbd_convolve8_avg;
sf->highbd_predict[1][0][0] = vp9_highbd_convolve8_horiz;
sf->highbd_predict[1][0][1] = vp9_highbd_convolve8_avg_horiz;
} else {
// Must always scale in both directions.
sf->high_predict[0][0][0] = vp9_high_convolve8;
sf->high_predict[0][0][1] = vp9_high_convolve8_avg;
sf->high_predict[0][1][0] = vp9_high_convolve8;
sf->high_predict[0][1][1] = vp9_high_convolve8_avg;
sf->high_predict[1][0][0] = vp9_high_convolve8;
sf->high_predict[1][0][1] = vp9_high_convolve8_avg;
sf->highbd_predict[0][0][0] = vp9_highbd_convolve8;
sf->highbd_predict[0][0][1] = vp9_highbd_convolve8_avg;
sf->highbd_predict[0][1][0] = vp9_highbd_convolve8;
sf->highbd_predict[0][1][1] = vp9_highbd_convolve8_avg;
sf->highbd_predict[1][0][0] = vp9_highbd_convolve8;
sf->highbd_predict[1][0][1] = vp9_highbd_convolve8_avg;
}
}
// 2D subpel motion always gets filtered in both directions.
sf->high_predict[1][1][0] = vp9_high_convolve8;
sf->high_predict[1][1][1] = vp9_high_convolve8_avg;
sf->highbd_predict[1][1][0] = vp9_highbd_convolve8;
sf->highbd_predict[1][1][1] = vp9_highbd_convolve8_avg;
}
#endif
}

2
vp9/common/vp9_scale.h
Просмотреть файл

@ -33,7 +33,7 @@ struct scale_factors {
convolve_fn_t predict[2][2][2]; // horiz, vert, avg
#if CONFIG_VP9_HIGHBITDEPTH
high_convolve_fn_t high_predict[2][2][2]; // horiz, vert, avg
highbd_convolve_fn_t highbd_predict[2][2][2]; // horiz, vert, avg
#endif
};

289
vp9/common/x86/vp9_asm_stubs.c
Просмотреть файл

@ -142,7 +142,7 @@ void vp9_convolve8_##avg##opt(const uint8_t *src, ptrdiff_t src_stride, \
#if CONFIG_VP9_HIGHBITDEPTH
typedef void high_filter8_1dfunction (
typedef void highbd_filter8_1dfunction (
const uint16_t *src_ptr,
const ptrdiff_t src_pitch,
uint16_t *output_ptr,
@ -153,87 +153,88 @@ typedef void high_filter8_1dfunction (
);
#define HIGH_FUN_CONV_1D(name, step_q4, filter, dir, src_start, avg, opt) \
void vp9_high_convolve8_##name##_##opt(const uint8_t *src8, \
ptrdiff_t src_stride, \
uint8_t *dst8, ptrdiff_t dst_stride, \
const int16_t *filter_x, \
int x_step_q4, \
const int16_t *filter_y, \
int y_step_q4, \
int w, int h, int bd) { \
void vp9_highbd_convolve8_##name##_##opt(const uint8_t *src8, \
ptrdiff_t src_stride, \
uint8_t *dst8, \
ptrdiff_t dst_stride, \
const int16_t *filter_x, \
int x_step_q4, \
const int16_t *filter_y, \
int y_step_q4, \
int w, int h, int bd) { \
if (step_q4 == 16 && filter[3] != 128) { \
uint16_t *src = CONVERT_TO_SHORTPTR(src8); \
uint16_t *dst = CONVERT_TO_SHORTPTR(dst8); \
if (filter[0] || filter[1] || filter[2]) { \
while (w >= 16) { \
vp9_high_filter_block1d16_##dir##8_##avg##opt(src_start, \
src_stride, \
dst, \
dst_stride, \
h, \
filter, \
bd); \
vp9_highbd_filter_block1d16_##dir##8_##avg##opt(src_start, \
src_stride, \
dst, \
dst_stride, \
h, \
filter, \
bd); \
src += 16; \
dst += 16; \
w -= 16; \
} \
while (w >= 8) { \
vp9_high_filter_block1d8_##dir##8_##avg##opt(src_start, \
src_stride, \
dst, \
dst_stride, \
h, \
filter, \
bd); \
vp9_highbd_filter_block1d8_##dir##8_##avg##opt(src_start, \
src_stride, \
dst, \
dst_stride, \
h, \
filter, \
bd); \
src += 8; \
dst += 8; \
w -= 8; \
} \
while (w >= 4) { \
vp9_high_filter_block1d4_##dir##8_##avg##opt(src_start, \
src_stride, \
dst, \
dst_stride, \
h, \
filter, \
bd); \
vp9_highbd_filter_block1d4_##dir##8_##avg##opt(src_start, \
src_stride, \
dst, \
dst_stride, \
h, \
filter, \
bd); \
src += 4; \
dst += 4; \
w -= 4; \
} \
} else { \
while (w >= 16) { \
vp9_high_filter_block1d16_##dir##2_##avg##opt(src, \
src_stride, \
dst, \
dst_stride, \
h, \
filter, \
bd); \
vp9_highbd_filter_block1d16_##dir##2_##avg##opt(src, \
src_stride, \
dst, \
dst_stride, \
h, \
filter, \
bd); \
src += 16; \
dst += 16; \
w -= 16; \
} \
while (w >= 8) { \
vp9_high_filter_block1d8_##dir##2_##avg##opt(src, \
src_stride, \
dst, \
dst_stride, \
h, \
filter, \
bd); \
vp9_highbd_filter_block1d8_##dir##2_##avg##opt(src, \
src_stride, \
dst, \
dst_stride, \
h, \
filter, \
bd); \
src += 8; \
dst += 8; \
w -= 8; \
} \
while (w >= 4) { \
vp9_high_filter_block1d4_##dir##2_##avg##opt(src, \
src_stride, \
dst, \
dst_stride, \
h, \
filter, \
bd); \
vp9_highbd_filter_block1d4_##dir##2_##avg##opt(src, \
src_stride, \
dst, \
dst_stride, \
h, \
filter, \
bd); \
src += 4; \
dst += 4; \
w -= 4; \
@ -241,47 +242,51 @@ typedef void high_filter8_1dfunction (
} \
} \
if (w) { \
vp9_high_convolve8_##name##_c(src8, src_stride, dst8, dst_stride, \
filter_x, x_step_q4, filter_y, y_step_q4, \
w, h, bd); \
vp9_highbd_convolve8_##name##_c(src8, src_stride, dst8, dst_stride, \
filter_x, x_step_q4, filter_y, y_step_q4, \
w, h, bd); \
} \
}
#define HIGH_FUN_CONV_2D(avg, opt) \
void vp9_high_convolve8_##avg##opt(const uint8_t *src, ptrdiff_t src_stride, \
uint8_t *dst, ptrdiff_t dst_stride, \
const int16_t *filter_x, int x_step_q4, \
const int16_t *filter_y, int y_step_q4, \
int w, int h, int bd) { \
void vp9_highbd_convolve8_##avg##opt(const uint8_t *src, ptrdiff_t src_stride, \
uint8_t *dst, ptrdiff_t dst_stride, \
const int16_t *filter_x, int x_step_q4, \
const int16_t *filter_y, int y_step_q4, \
int w, int h, int bd) { \
assert(w <= 64); \
assert(h <= 64); \
if (x_step_q4 == 16 && y_step_q4 == 16) { \
if (filter_x[0] || filter_x[1] || filter_x[2] || filter_x[3] == 128 || \
filter_y[0] || filter_y[1] || filter_y[2] || filter_y[3] == 128) { \
DECLARE_ALIGNED_ARRAY(16, uint16_t, fdata2, 64 * 71); \
vp9_high_convolve8_horiz_##opt(src - 3 * src_stride, src_stride, \
CONVERT_TO_BYTEPTR(fdata2), 64, \
filter_x, x_step_q4, filter_y, y_step_q4, \
w, h + 7, bd); \
vp9_high_convolve8_##avg##vert_##opt(CONVERT_TO_BYTEPTR(fdata2) + 192, \
64, dst, dst_stride, \
filter_x, x_step_q4, filter_y, \
y_step_q4, w, h, bd); \
vp9_highbd_convolve8_horiz_##opt(src - 3 * src_stride, src_stride, \
CONVERT_TO_BYTEPTR(fdata2), 64, \
filter_x, x_step_q4, \
filter_y, y_step_q4, \
w, h + 7, bd); \
vp9_highbd_convolve8_##avg##vert_##opt(CONVERT_TO_BYTEPTR(fdata2) + 192, \
64, dst, dst_stride, \
filter_x, x_step_q4, \
filter_y, y_step_q4, \
w, h, bd); \
} else { \
DECLARE_ALIGNED_ARRAY(16, uint16_t, fdata2, 64 * 65); \
vp9_high_convolve8_horiz_##opt(src, src_stride, \
CONVERT_TO_BYTEPTR(fdata2), 64, \
filter_x, x_step_q4, filter_y, y_step_q4, \
w, h + 1, bd); \
vp9_high_convolve8_##avg##vert_##opt(CONVERT_TO_BYTEPTR(fdata2), 64, \
dst, dst_stride, \
filter_x, x_step_q4, filter_y, \
y_step_q4, w, h, bd); \
vp9_highbd_convolve8_horiz_##opt(src, src_stride, \
CONVERT_TO_BYTEPTR(fdata2), 64, \
filter_x, x_step_q4, \
filter_y, y_step_q4, \
w, h + 1, bd); \
vp9_highbd_convolve8_##avg##vert_##opt(CONVERT_TO_BYTEPTR(fdata2), 64, \
dst, dst_stride, \
filter_x, x_step_q4, \
filter_y, y_step_q4, \
w, h, bd); \
} \
} else { \
vp9_high_convolve8_##avg##c(src, src_stride, dst, dst_stride, \
filter_x, x_step_q4, filter_y, y_step_q4, w, \
h, bd); \
vp9_highbd_convolve8_##avg##c(src, src_stride, dst, dst_stride, \
filter_x, x_step_q4, filter_y, y_step_q4, w, \
h, bd); \
} \
}
#endif // CONFIG_VP9_HIGHBITDEPTH
@ -485,72 +490,84 @@ FUN_CONV_2D(, sse2);
FUN_CONV_2D(avg_ , sse2);
#if CONFIG_VP9_HIGHBITDEPTH && ARCH_X86_64
high_filter8_1dfunction vp9_high_filter_block1d16_v8_sse2;
high_filter8_1dfunction vp9_high_filter_block1d16_h8_sse2;
high_filter8_1dfunction vp9_high_filter_block1d8_v8_sse2;
high_filter8_1dfunction vp9_high_filter_block1d8_h8_sse2;
high_filter8_1dfunction vp9_high_filter_block1d4_v8_sse2;
high_filter8_1dfunction vp9_high_filter_block1d4_h8_sse2;
high_filter8_1dfunction vp9_high_filter_block1d16_v8_avg_sse2;
high_filter8_1dfunction vp9_high_filter_block1d16_h8_avg_sse2;
high_filter8_1dfunction vp9_high_filter_block1d8_v8_avg_sse2;
high_filter8_1dfunction vp9_high_filter_block1d8_h8_avg_sse2;
high_filter8_1dfunction vp9_high_filter_block1d4_v8_avg_sse2;
high_filter8_1dfunction vp9_high_filter_block1d4_h8_avg_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d16_v8_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d16_h8_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d8_v8_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d8_h8_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d4_v8_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d4_h8_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d16_v8_avg_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d16_h8_avg_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d8_v8_avg_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d8_h8_avg_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d4_v8_avg_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d4_h8_avg_sse2;
high_filter8_1dfunction vp9_high_filter_block1d16_v2_sse2;
high_filter8_1dfunction vp9_high_filter_block1d16_h2_sse2;
high_filter8_1dfunction vp9_high_filter_block1d8_v2_sse2;
high_filter8_1dfunction vp9_high_filter_block1d8_h2_sse2;
high_filter8_1dfunction vp9_high_filter_block1d4_v2_sse2;
high_filter8_1dfunction vp9_high_filter_block1d4_h2_sse2;
high_filter8_1dfunction vp9_high_filter_block1d16_v2_avg_sse2;
high_filter8_1dfunction vp9_high_filter_block1d16_h2_avg_sse2;
high_filter8_1dfunction vp9_high_filter_block1d8_v2_avg_sse2;
high_filter8_1dfunction vp9_high_filter_block1d8_h2_avg_sse2;
high_filter8_1dfunction vp9_high_filter_block1d4_v2_avg_sse2;
high_filter8_1dfunction vp9_high_filter_block1d4_h2_avg_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d16_v2_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d16_h2_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d8_v2_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d8_h2_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d4_v2_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d4_h2_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d16_v2_avg_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d16_h2_avg_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d8_v2_avg_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d8_h2_avg_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d4_v2_avg_sse2;
highbd_filter8_1dfunction vp9_highbd_filter_block1d4_h2_avg_sse2;
// void vp9_high_convolve8_horiz_sse2(const uint8_t *src, ptrdiff_t src_stride,
// uint8_t *dst, ptrdiff_t dst_stride,
// const int16_t *filter_x, int x_step_q4,
// const int16_t *filter_y, int y_step_q4,
// int w, int h, int bd);
// void vp9_high_convolve8_vert_sse2(const uint8_t *src, ptrdiff_t src_stride,
// uint8_t *dst, ptrdiff_t dst_stride,
// const int16_t *filter_x, int x_step_q4,
// const int16_t *filter_y, int y_step_q4,
// int w, int h, int bd);
// void vp9_high_convolve8_avg_horiz_sse2(const uint8_t *src,
// ptrdiff_t src_stride,
// uint8_t *dst, ptrdiff_t dst_stride,
// const int16_t *filter_x,
// int x_step_q4,
// const int16_t *filter_y,
// int y_step_q4,
// int w, int h, int bd);
// void vp9_high_convolve8_avg_vert_sse2(const uint8_t *src,
// ptrdiff_t src_stride,
// uint8_t *dst, ptrdiff_t dst_stride,
// const int16_t *filter_x, int x_step_q4,
// const int16_t *filter_y, int y_step_q4,
// int w, int h, int bd);
// void vp9_highbd_convolve8_horiz_sse2(const uint8_t *src,
// ptrdiff_t src_stride,
// uint8_t *dst,
// ptrdiff_t dst_stride,
// const int16_t *filter_x,
// int x_step_q4,
// const int16_t *filter_y,
// int y_step_q4,
// int w, int h, int bd);
// void vp9_highbd_convolve8_vert_sse2(const uint8_t *src,
// ptrdiff_t src_stride,
// uint8_t *dst,
// ptrdiff_t dst_stride,
// const int16_t *filter_x,
// int x_step_q4,
// const int16_t *filter_y,
// int y_step_q4,
// int w, int h, int bd);
// void vp9_highbd_convolve8_avg_horiz_sse2(const uint8_t *src,
// ptrdiff_t src_stride,
// uint8_t *dst,
// ptrdiff_t dst_stride,
// const int16_t *filter_x,
// int x_step_q4,
// const int16_t *filter_y,
// int y_step_q4,
// int w, int h, int bd);
// void vp9_highbd_convolve8_avg_vert_sse2(const uint8_t *src,
// ptrdiff_t src_stride,
// uint8_t *dst,
// ptrdiff_t dst_stride,
// const int16_t *filter_x,
// int x_step_q4,
// const int16_t *filter_y,
// int y_step_q4,
// int w, int h, int bd);
HIGH_FUN_CONV_1D(horiz, x_step_q4, filter_x, h, src, , sse2);
HIGH_FUN_CONV_1D(vert, y_step_q4, filter_y, v, src - src_stride * 3, , sse2);
HIGH_FUN_CONV_1D(avg_horiz, x_step_q4, filter_x, h, src, avg_, sse2);
HIGH_FUN_CONV_1D(avg_vert, y_step_q4, filter_y, v, src - src_stride * 3, avg_,
sse2);
// void vp9_high_convolve8_sse2(const uint8_t *src, ptrdiff_t src_stride,
// uint8_t *dst, ptrdiff_t dst_stride,
// const int16_t *filter_x, int x_step_q4,
// const int16_t *filter_y, int y_step_q4,
// int w, int h, int bd);
// void vp9_high_convolve8_avg_sse2(const uint8_t *src, ptrdiff_t src_stride,
// uint8_t *dst, ptrdiff_t dst_stride,
// const int16_t *filter_x, int x_step_q4,
// const int16_t *filter_y, int y_step_q4,
// int w, int h, int bd);
// void vp9_highbd_convolve8_sse2(const uint8_t *src, ptrdiff_t src_stride,
// uint8_t *dst, ptrdiff_t dst_stride,
// const int16_t *filter_x, int x_step_q4,
// const int16_t *filter_y, int y_step_q4,
// int w, int h, int bd);
// void vp9_highbd_convolve8_avg_sse2(const uint8_t *src, ptrdiff_t src_stride,
// uint8_t *dst, ptrdiff_t dst_stride,
// const int16_t *filter_x, int x_step_q4,
// const int16_t *filter_y, int y_step_q4,
// int w, int h, int bd);
HIGH_FUN_CONV_2D(, sse2);
HIGH_FUN_CONV_2D(avg_ , sse2);
#endif // CONFIG_VP9_HIGHBITDEPTH && ARCH_X86_64

24
vp9/common/x86/vp9_high_intrapred_sse2.asm
Просмотреть файл

@ -18,7 +18,7 @@ pw_32: times 4 dd 32
SECTION .text
INIT_MMX sse
cglobal high_dc_predictor_4x4, 4, 5, 4, dst, stride, above, left, goffset
cglobal highbd_dc_predictor_4x4, 4, 5, 4, dst, stride, above, left, goffset
GET_GOT goffsetq
movq m0, [aboveq]
@ -45,7 +45,7 @@ cglobal high_dc_predictor_4x4, 4, 5, 4, dst, stride, above, left, goffset
RET
INIT_XMM sse2
cglobal high_dc_predictor_8x8, 4, 5, 4, dst, stride, above, left, goffset
cglobal highbd_dc_predictor_8x8, 4, 5, 4, dst, stride, above, left, goffset
GET_GOT goffsetq
pxor m1, m1
@ -80,7 +80,7 @@ cglobal high_dc_predictor_8x8, 4, 5, 4, dst, stride, above, left, goffset
RET
INIT_XMM sse2
cglobal high_dc_predictor_16x16, 4, 5, 5, dst, stride, above, left, goffset
cglobal highbd_dc_predictor_16x16, 4, 5, 5, dst, stride, above, left, goffset
GET_GOT goffsetq
pxor m1, m1
@ -124,7 +124,7 @@ cglobal high_dc_predictor_16x16, 4, 5, 5, dst, stride, above, left, goffset
%if ARCH_X86_64
INIT_XMM sse2
cglobal high_dc_predictor_32x32, 4, 5, 9, dst, stride, above, left, goffset
cglobal highbd_dc_predictor_32x32, 4, 5, 9, dst, stride, above, left, goffset
GET_GOT goffsetq
pxor m1, m1
@ -184,7 +184,7 @@ cglobal high_dc_predictor_32x32, 4, 5, 9, dst, stride, above, left, goffset
%endif
INIT_MMX sse
cglobal high_v_predictor_4x4, 3, 3, 1, dst, stride, above
cglobal highbd_v_predictor_4x4, 3, 3, 1, dst, stride, above
movq m0, [aboveq]
movq [dstq ], m0
movq [dstq+strideq*2], m0
@ -194,7 +194,7 @@ cglobal high_v_predictor_4x4, 3, 3, 1, dst, stride, above
RET
INIT_XMM sse2
cglobal high_v_predictor_8x8, 3, 3, 1, dst, stride, above
cglobal highbd_v_predictor_8x8, 3, 3, 1, dst, stride, above
mova m0, [aboveq]
DEFINE_ARGS dst, stride, stride3
lea stride3q, [strideq*3]
@ -210,7 +210,7 @@ cglobal high_v_predictor_8x8, 3, 3, 1, dst, stride, above
RET
INIT_XMM sse2
cglobal high_v_predictor_16x16, 3, 4, 2, dst, stride, above
cglobal highbd_v_predictor_16x16, 3, 4, 2, dst, stride, above
mova m0, [aboveq]
mova m1, [aboveq+16]
DEFINE_ARGS dst, stride, stride3, nlines4
@ -231,7 +231,7 @@ cglobal high_v_predictor_16x16, 3, 4, 2, dst, stride, above
REP_RET
INIT_XMM sse2
cglobal high_v_predictor_32x32, 3, 4, 4, dst, stride, above
cglobal highbd_v_predictor_32x32, 3, 4, 4, dst, stride, above
mova m0, [aboveq]
mova m1, [aboveq+16]
mova m2, [aboveq+32]
@ -262,7 +262,7 @@ cglobal high_v_predictor_32x32, 3, 4, 4, dst, stride, above
REP_RET
INIT_MMX sse
cglobal high_tm_predictor_4x4, 5, 6, 5, dst, stride, above, left, bps, one
cglobal highbd_tm_predictor_4x4, 5, 6, 5, dst, stride, above, left, bps, one
movd m1, [aboveq-2]
movq m0, [aboveq]
pshufw m1, m1, 0x0
@ -300,7 +300,7 @@ cglobal high_tm_predictor_4x4, 5, 6, 5, dst, stride, above, left, bps, one
REP_RET
INIT_XMM sse2
cglobal high_tm_predictor_8x8, 5, 6, 5, dst, stride, above, left, bps, one
cglobal highbd_tm_predictor_8x8, 5, 6, 5, dst, stride, above, left, bps, one
movd m1, [aboveq-2]
mova m0, [aboveq]
pshuflw m1, m1, 0x0
@ -345,7 +345,7 @@ cglobal high_tm_predictor_8x8, 5, 6, 5, dst, stride, above, left, bps, one
%if ARCH_X86_64
INIT_XMM sse2
cglobal high_tm_predictor_16x16, 5, 6, 8, dst, stride, above, left, bps, one
cglobal highbd_tm_predictor_16x16, 5, 6, 8, dst, stride, above, left, bps, one
movd m2, [aboveq-2]
mova m0, [aboveq]
mova m1, [aboveq+16]
@ -399,7 +399,7 @@ cglobal high_tm_predictor_16x16, 5, 6, 8, dst, stride, above, left, bps, one
REP_RET
INIT_XMM sse2
cglobal high_tm_predictor_32x32, 5, 6, 12, dst, stride, above, left, bps, one
cglobal highbd_tm_predictor_32x32, 5, 6, 12, dst, stride, above, left, bps, one
movd m0, [aboveq-2]
mova m1, [aboveq]
mova m2, [aboveq+16]

36
vp9/common/x86/vp9_high_loopfilter_intrin_sse2.c
Просмотреть файл

@ -79,7 +79,7 @@ static void highbd_mb_lpf_horizontal_edge_w_sse2_8(uint16_t *s,
q0 = _mm_load_si128((__m128i *)(s + 0 * p));
p0 = _mm_load_si128((__m128i *)(s - 1 * p));
// high_filter_mask
// highbd_filter_mask
abs_p1p0 = _mm_or_si128(_mm_subs_epu16(p1, p0), _mm_subs_epu16(p0, p1));
abs_q1q0 = _mm_or_si128(_mm_subs_epu16(q1, q0), _mm_subs_epu16(q0, q1));
@ -88,7 +88,7 @@ static void highbd_mb_lpf_horizontal_edge_w_sse2_8(uint16_t *s,
abs_p0q0 = _mm_or_si128(_mm_subs_epu16(p0, q0), _mm_subs_epu16(q0, p0));
abs_p1q1 = _mm_or_si128(_mm_subs_epu16(p1, q1), _mm_subs_epu16(q1, p1));
// high_hev_mask (in C code this is actually called from high_filter4)
// highbd_hev_mask (in C code this is actually called from highbd_filter4)
flat = _mm_max_epi16(abs_p1p0, abs_q1q0);
hev = _mm_subs_epu16(flat, thresh);
hev = _mm_xor_si128(_mm_cmpeq_epi16(hev, zero), ffff);
@ -118,7 +118,7 @@ static void highbd_mb_lpf_horizontal_edge_w_sse2_8(uint16_t *s,
mask = _mm_cmpeq_epi16(mask, zero); // return ~mask
// lp filter
// high_filter4
// highbd_filter4
t4 = _mm_set1_epi16(4);
t3 = _mm_set1_epi16(3);
t80 = _mm_slli_epi16(_mm_set1_epi16(0x80), bd - 8);
@ -160,10 +160,10 @@ static void highbd_mb_lpf_horizontal_edge_w_sse2_8(uint16_t *s,
ps1 = _mm_adds_epi16(
signed_char_clamp_bd_sse2(_mm_adds_epi16(ps1, filt), bd),
t80);
// end high_filter4
// end highbd_filter4
// loopfilter done
// high_flat_mask4
// highbd_flat_mask4
flat = _mm_max_epi16(_mm_or_si128(_mm_subs_epu16(p2, p0),
_mm_subs_epu16(p0, p2)),
_mm_or_si128(_mm_subs_epu16(p3, p0),
@ -190,7 +190,7 @@ static void highbd_mb_lpf_horizontal_edge_w_sse2_8(uint16_t *s,
p7 = _mm_load_si128((__m128i *)(s - 8 * p));
q7 = _mm_load_si128((__m128i *)(s + 7 * p));
// high_flat_mask5 (arguments passed in are p0, q0, p4-p7, q4-q7
// highbd_flat_mask5 (arguments passed in are p0, q0, p4-p7, q4-q7
// but referred to as p0-p4 & q0-q4 in fn)
flat2 = _mm_max_epi16(_mm_or_si128(_mm_subs_epu16(p4, p0),
_mm_subs_epu16(p0, p4)),
@ -218,7 +218,7 @@ static void highbd_mb_lpf_horizontal_edge_w_sse2_8(uint16_t *s,
flat2 = _mm_subs_epu16(flat2, _mm_slli_epi16(one, bd - 8));
flat2 = _mm_cmpeq_epi16(flat2, zero);
flat2 = _mm_and_si128(flat2, flat); // flat2 & flat & mask
// end high_flat_mask5
// end highbd_flat_mask5
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// flat and wide flat calculations
@ -326,7 +326,7 @@ static void highbd_mb_lpf_horizontal_edge_w_sse2_8(uint16_t *s,
// wide flat
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// high_filter8
// highbd_filter8
p2 = _mm_andnot_si128(flat, p2);
// p2 remains unchanged if !(flat && mask)
flat_p2 = _mm_and_si128(flat, flat_p2);
@ -353,9 +353,9 @@ static void highbd_mb_lpf_horizontal_edge_w_sse2_8(uint16_t *s,
qs0 = _mm_andnot_si128(flat, qs0);
flat_q0 = _mm_and_si128(flat, flat_q0);
q0 = _mm_or_si128(qs0, flat_q0); // full list of q0 values
// end high_filter8
// end highbd_filter8
// high_filter16
// highbd_filter16
p6 = _mm_andnot_si128(flat2, p6);
// p6 remains unchanged if !(flat2 && flat && mask)
flat2_p6 = _mm_and_si128(flat2, flat2_p6);
@ -398,12 +398,12 @@ static void highbd_mb_lpf_horizontal_edge_w_sse2_8(uint16_t *s,
_mm_store_si128((__m128i *)(s + 4 * p), q4);
p3 = _mm_andnot_si128(flat2, p3);
// p3 takes value from high_filter8 if !(flat2 && flat && mask)
// p3 takes value from highbd_filter8 if !(flat2 && flat && mask)
flat2_p3 = _mm_and_si128(flat2, flat2_p3);
// get values for when (flat2 && flat && mask)
p3 = _mm_or_si128(p3, flat2_p3); // full list of p3 values
q3 = _mm_andnot_si128(flat2, q3);
// q3 takes value from high_filter8 if !(flat2 && flat && mask)
// q3 takes value from highbd_filter8 if !(flat2 && flat && mask)
flat2_q3 = _mm_and_si128(flat2, flat2_q3);
// get values for when (flat2 && flat && mask)
q3 = _mm_or_si128(q3, flat2_q3); // full list of q3 values
@ -411,13 +411,13 @@ static void highbd_mb_lpf_horizontal_edge_w_sse2_8(uint16_t *s,
_mm_store_si128((__m128i *)(s + 3 * p), q3);
p2 = _mm_andnot_si128(flat2, p2);
// p2 takes value from high_filter8 if !(flat2 && flat && mask)
// p2 takes value from highbd_filter8 if !(flat2 && flat && mask)
flat2_p2 = _mm_and_si128(flat2, flat2_p2);
// get values for when (flat2 && flat && mask)
p2 = _mm_or_si128(p2, flat2_p2);
// full list of p2 values
q2 = _mm_andnot_si128(flat2, q2);
// q2 takes value from high_filter8 if !(flat2 && flat && mask)
// q2 takes value from highbd_filter8 if !(flat2 && flat && mask)
flat2_q2 = _mm_and_si128(flat2, flat2_q2);
// get values for when (flat2 && flat && mask)
q2 = _mm_or_si128(q2, flat2_q2); // full list of q2 values
@ -425,12 +425,12 @@ static void highbd_mb_lpf_horizontal_edge_w_sse2_8(uint16_t *s,
_mm_store_si128((__m128i *)(s + 2 * p), q2);
p1 = _mm_andnot_si128(flat2, p1);
// p1 takes value from high_filter8 if !(flat2 && flat && mask)
// p1 takes value from highbd_filter8 if !(flat2 && flat && mask)
flat2_p1 = _mm_and_si128(flat2, flat2_p1);
// get values for when (flat2 && flat && mask)
p1 = _mm_or_si128(p1, flat2_p1); // full list of p1 values
q1 = _mm_andnot_si128(flat2, q1);
// q1 takes value from high_filter8 if !(flat2 && flat && mask)
// q1 takes value from highbd_filter8 if !(flat2 && flat && mask)
flat2_q1 = _mm_and_si128(flat2, flat2_q1);
// get values for when (flat2 && flat && mask)
q1 = _mm_or_si128(q1, flat2_q1); // full list of q1 values
@ -438,12 +438,12 @@ static void highbd_mb_lpf_horizontal_edge_w_sse2_8(uint16_t *s,
_mm_store_si128((__m128i *)(s + 1 * p), q1);
p0 = _mm_andnot_si128(flat2, p0);
// p0 takes value from high_filter8 if !(flat2 && flat && mask)
// p0 takes value from highbd_filter8 if !(flat2 && flat && mask)
flat2_p0 = _mm_and_si128(flat2, flat2_p0);
// get values for when (flat2 && flat && mask)
p0 = _mm_or_si128(p0, flat2_p0); // full list of p0 values
q0 = _mm_andnot_si128(flat2, q0);
// q0 takes value from high_filter8 if !(flat2 && flat && mask)
// q0 takes value from highbd_filter8 if !(flat2 && flat && mask)
flat2_q0 = _mm_and_si128(flat2, flat2_q0);
// get values for when (flat2 && flat && mask)
q0 = _mm_or_si128(q0, flat2_q0); // full list of q0 values

48
vp9/common/x86/vp9_high_subpixel_8t_sse2.asm
Просмотреть файл

@ -206,8 +206,8 @@
; unsigned int output_height,
; short *filter
;)
global sym(vp9_high_filter_block1d4_v8_sse2) PRIVATE
sym(vp9_high_filter_block1d4_v8_sse2):
global sym(vp9_highbd_filter_block1d4_v8_sse2) PRIVATE
sym(vp9_highbd_filter_block1d4_v8_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -276,8 +276,8 @@ sym(vp9_high_filter_block1d4_v8_sse2):
; unsigned int output_height,
; short *filter
;)
global sym(vp9_high_filter_block1d8_v8_sse2) PRIVATE
sym(vp9_high_filter_block1d8_v8_sse2):
global sym(vp9_highbd_filter_block1d8_v8_sse2) PRIVATE
sym(vp9_highbd_filter_block1d8_v8_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -335,8 +335,8 @@ sym(vp9_high_filter_block1d8_v8_sse2):
; unsigned int output_height,
; short *filter
;)
global sym(vp9_high_filter_block1d16_v8_sse2) PRIVATE
sym(vp9_high_filter_block1d16_v8_sse2):
global sym(vp9_highbd_filter_block1d16_v8_sse2) PRIVATE
sym(vp9_highbd_filter_block1d16_v8_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -389,8 +389,8 @@ sym(vp9_high_filter_block1d16_v8_sse2):
pop rbp
ret
global sym(vp9_high_filter_block1d4_v8_avg_sse2) PRIVATE
sym(vp9_high_filter_block1d4_v8_avg_sse2):
global sym(vp9_highbd_filter_block1d4_v8_avg_sse2) PRIVATE
sym(vp9_highbd_filter_block1d4_v8_avg_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -450,8 +450,8 @@ sym(vp9_high_filter_block1d4_v8_avg_sse2):
pop rbp
ret
global sym(vp9_high_filter_block1d8_v8_avg_sse2) PRIVATE
sym(vp9_high_filter_block1d8_v8_avg_sse2):
global sym(vp9_highbd_filter_block1d8_v8_avg_sse2) PRIVATE
sym(vp9_highbd_filter_block1d8_v8_avg_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -499,8 +499,8 @@ sym(vp9_high_filter_block1d8_v8_avg_sse2):
pop rbp
ret
global sym(vp9_high_filter_block1d16_v8_avg_sse2) PRIVATE
sym(vp9_high_filter_block1d16_v8_avg_sse2):
global sym(vp9_highbd_filter_block1d16_v8_avg_sse2) PRIVATE
sym(vp9_highbd_filter_block1d16_v8_avg_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -561,8 +561,8 @@ sym(vp9_high_filter_block1d16_v8_avg_sse2):
; unsigned int output_height,
; short *filter
;)
global sym(vp9_high_filter_block1d4_h8_sse2) PRIVATE
sym(vp9_high_filter_block1d4_h8_sse2):
global sym(vp9_highbd_filter_block1d4_h8_sse2) PRIVATE
sym(vp9_highbd_filter_block1d4_h8_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -636,8 +636,8 @@ sym(vp9_high_filter_block1d4_h8_sse2):
; unsigned int output_height,
; short *filter
;)
global sym(vp9_high_filter_block1d8_h8_sse2) PRIVATE
sym(vp9_high_filter_block1d8_h8_sse2):
global sym(vp9_highbd_filter_block1d8_h8_sse2) PRIVATE
sym(vp9_highbd_filter_block1d8_h8_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -702,8 +702,8 @@ sym(vp9_high_filter_block1d8_h8_sse2):
; unsigned int output_height,
; short *filter
;)
global sym(vp9_high_filter_block1d16_h8_sse2) PRIVATE
sym(vp9_high_filter_block1d16_h8_sse2):
global sym(vp9_highbd_filter_block1d16_h8_sse2) PRIVATE
sym(vp9_highbd_filter_block1d16_h8_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -770,8 +770,8 @@ sym(vp9_high_filter_block1d16_h8_sse2):
pop rbp
ret
global sym(vp9_high_filter_block1d4_h8_avg_sse2) PRIVATE
sym(vp9_high_filter_block1d4_h8_avg_sse2):
global sym(vp9_highbd_filter_block1d4_h8_avg_sse2) PRIVATE
sym(vp9_highbd_filter_block1d4_h8_avg_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -836,8 +836,8 @@ sym(vp9_high_filter_block1d4_h8_avg_sse2):
pop rbp
ret
global sym(vp9_high_filter_block1d8_h8_avg_sse2) PRIVATE
sym(vp9_high_filter_block1d8_h8_avg_sse2):
global sym(vp9_highbd_filter_block1d8_h8_avg_sse2) PRIVATE
sym(vp9_highbd_filter_block1d8_h8_avg_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -893,8 +893,8 @@ sym(vp9_high_filter_block1d8_h8_avg_sse2):
pop rbp
ret
global sym(vp9_high_filter_block1d16_h8_avg_sse2) PRIVATE
sym(vp9_high_filter_block1d16_h8_avg_sse2):
global sym(vp9_highbd_filter_block1d16_h8_avg_sse2) PRIVATE
sym(vp9_highbd_filter_block1d16_h8_avg_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7

48
vp9/common/x86/vp9_high_subpixel_bilinear_sse2.asm
Просмотреть файл

@ -171,8 +171,8 @@
%endm
%endif
global sym(vp9_high_filter_block1d4_v2_sse2) PRIVATE
sym(vp9_high_filter_block1d4_v2_sse2):
global sym(vp9_highbd_filter_block1d4_v2_sse2) PRIVATE
sym(vp9_highbd_filter_block1d4_v2_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -196,8 +196,8 @@ sym(vp9_high_filter_block1d4_v2_sse2):
ret
%if ARCH_X86_64
global sym(vp9_high_filter_block1d8_v2_sse2) PRIVATE
sym(vp9_high_filter_block1d8_v2_sse2):
global sym(vp9_highbd_filter_block1d8_v2_sse2) PRIVATE
sym(vp9_highbd_filter_block1d8_v2_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -222,8 +222,8 @@ sym(vp9_high_filter_block1d8_v2_sse2):
pop rbp
ret
global sym(vp9_high_filter_block1d16_v2_sse2) PRIVATE
sym(vp9_high_filter_block1d16_v2_sse2):
global sym(vp9_highbd_filter_block1d16_v2_sse2) PRIVATE
sym(vp9_highbd_filter_block1d16_v2_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -251,8 +251,8 @@ sym(vp9_high_filter_block1d16_v2_sse2):
ret
%endif
global sym(vp9_high_filter_block1d4_v2_avg_sse2) PRIVATE
sym(vp9_high_filter_block1d4_v2_avg_sse2):
global sym(vp9_highbd_filter_block1d4_v2_avg_sse2) PRIVATE
sym(vp9_highbd_filter_block1d4_v2_avg_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -276,8 +276,8 @@ sym(vp9_high_filter_block1d4_v2_avg_sse2):
ret
%if ARCH_X86_64
global sym(vp9_high_filter_block1d8_v2_avg_sse2) PRIVATE
sym(vp9_high_filter_block1d8_v2_avg_sse2):
global sym(vp9_highbd_filter_block1d8_v2_avg_sse2) PRIVATE
sym(vp9_highbd_filter_block1d8_v2_avg_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -302,8 +302,8 @@ sym(vp9_high_filter_block1d8_v2_avg_sse2):
pop rbp
ret
global sym(vp9_high_filter_block1d16_v2_avg_sse2) PRIVATE
sym(vp9_high_filter_block1d16_v2_avg_sse2):
global sym(vp9_highbd_filter_block1d16_v2_avg_sse2) PRIVATE
sym(vp9_highbd_filter_block1d16_v2_avg_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -331,8 +331,8 @@ sym(vp9_high_filter_block1d16_v2_avg_sse2):
ret
%endif
global sym(vp9_high_filter_block1d4_h2_sse2) PRIVATE
sym(vp9_high_filter_block1d4_h2_sse2):
global sym(vp9_highbd_filter_block1d4_h2_sse2) PRIVATE
sym(vp9_highbd_filter_block1d4_h2_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -357,8 +357,8 @@ sym(vp9_high_filter_block1d4_h2_sse2):
ret
%if ARCH_X86_64
global sym(vp9_high_filter_block1d8_h2_sse2) PRIVATE
sym(vp9_high_filter_block1d8_h2_sse2):
global sym(vp9_highbd_filter_block1d8_h2_sse2) PRIVATE
sym(vp9_highbd_filter_block1d8_h2_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -383,8 +383,8 @@ sym(vp9_high_filter_block1d8_h2_sse2):
pop rbp
ret
global sym(vp9_high_filter_block1d16_h2_sse2) PRIVATE
sym(vp9_high_filter_block1d16_h2_sse2):
global sym(vp9_highbd_filter_block1d16_h2_sse2) PRIVATE
sym(vp9_highbd_filter_block1d16_h2_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -412,8 +412,8 @@ sym(vp9_high_filter_block1d16_h2_sse2):
ret
%endif
global sym(vp9_high_filter_block1d4_h2_avg_sse2) PRIVATE
sym(vp9_high_filter_block1d4_h2_avg_sse2):
global sym(vp9_highbd_filter_block1d4_h2_avg_sse2) PRIVATE
sym(vp9_highbd_filter_block1d4_h2_avg_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -438,8 +438,8 @@ sym(vp9_high_filter_block1d4_h2_avg_sse2):
ret
%if ARCH_X86_64
global sym(vp9_high_filter_block1d8_h2_avg_sse2) PRIVATE
sym(vp9_high_filter_block1d8_h2_avg_sse2):
global sym(vp9_highbd_filter_block1d8_h2_avg_sse2) PRIVATE
sym(vp9_highbd_filter_block1d8_h2_avg_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7
@ -464,8 +464,8 @@ sym(vp9_high_filter_block1d8_h2_avg_sse2):
pop rbp
ret
global sym(vp9_high_filter_block1d16_h2_avg_sse2) PRIVATE
sym(vp9_high_filter_block1d16_h2_avg_sse2):
global sym(vp9_highbd_filter_block1d16_h2_avg_sse2) PRIVATE
sym(vp9_highbd_filter_block1d16_h2_avg_sse2):
push rbp
mov rbp, rsp
SHADOW_ARGS_TO_STACK 7

10
vp9/decoder/vp9_decodeframe.c
Просмотреть файл

@ -200,25 +200,25 @@ static void inverse_transform_block(MACROBLOCKD* xd, int plane, int block,
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
if (xd->lossless) {
tx_type = DCT_DCT;
vp9_high_iwht4x4_add(dqcoeff, dst, stride, eob, xd->bd);
vp9_highbd_iwht4x4_add(dqcoeff, dst, stride, eob, xd->bd);
} else {
const PLANE_TYPE plane_type = pd->plane_type;
switch (tx_size) {
case TX_4X4:
tx_type = get_tx_type_4x4(plane_type, xd, block);
vp9_high_iht4x4_add(tx_type, dqcoeff, dst, stride, eob, xd->bd);
vp9_highbd_iht4x4_add(tx_type, dqcoeff, dst, stride, eob, xd->bd);
break;
case TX_8X8:
tx_type = get_tx_type(plane_type, xd);
vp9_high_iht8x8_add(tx_type, dqcoeff, dst, stride, eob, xd->bd);
vp9_highbd_iht8x8_add(tx_type, dqcoeff, dst, stride, eob, xd->bd);
break;
case TX_16X16:
tx_type = get_tx_type(plane_type, xd);
vp9_high_iht16x16_add(tx_type, dqcoeff, dst, stride, eob, xd->bd);
vp9_highbd_iht16x16_add(tx_type, dqcoeff, dst, stride, eob, xd->bd);
break;
case TX_32X32:
tx_type = DCT_DCT;
vp9_high_idct32x32_add(dqcoeff, dst, stride, eob, xd->bd);
vp9_highbd_idct32x32_add(dqcoeff, dst, stride, eob, xd->bd);
break;
default:
assert(0 && "Invalid transform size");

6
vp9/encoder/vp9_aq_variance.c
Просмотреть файл

@ -131,9 +131,9 @@ static unsigned int block_variance(VP9_COMP *cpi, MACROBLOCK *x,
int avg;
#if CONFIG_VP9_HIGHBITDEPTH
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
high_variance(x->plane[0].src.buf, x->plane[0].src.stride,
CONVERT_TO_BYTEPTR(vp9_highbd_64_zeros), 0, bw, bh, &sse,
&avg);
highbd_variance(x->plane[0].src.buf, x->plane[0].src.stride,
CONVERT_TO_BYTEPTR(vp9_highbd_64_zeros), 0, bw, bh,
&sse, &avg);
sse >>= 2 * (xd->bd - 8);
avg >>= (xd->bd - 8);
} else {

4
vp9/encoder/vp9_block.h
Просмотреть файл

@ -120,8 +120,8 @@ struct macroblock {
void (*fwd_txm4x4)(const int16_t *input, tran_low_t *output, int stride);
void (*itxm_add)(const tran_low_t *input, uint8_t *dest, int stride, int eob);
#if CONFIG_VP9_HIGHBITDEPTH
void (*high_itxm_add)(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd);
void (*highbd_itxm_add)(const tran_low_t *input, uint8_t *dest, int stride,
int eob, int bd);
#endif
};

43
vp9/encoder/vp9_dct.c
Просмотреть файл

@ -1440,59 +1440,62 @@ void vp9_fdct32x32_rd_c(const int16_t *input, tran_low_t *out, int stride) {
}
#if CONFIG_VP9_HIGHBITDEPTH
void vp9_high_fdct4x4_c(const int16_t *input, tran_low_t *output, int stride) {
void vp9_highbd_fdct4x4_c(const int16_t *input, tran_low_t *output,
int stride) {
vp9_fdct4x4_c(input, output, stride);
}
void vp9_high_fht4x4_c(const int16_t *input, tran_low_t *output,
int stride, int tx_type) {
void vp9_highbd_fht4x4_c(const int16_t *input, tran_low_t *output,
int stride, int tx_type) {
vp9_fht4x4_c(input, output, stride, tx_type);
}
void vp9_high_fdct8x8_1_c(const int16_t *input, tran_low_t *final_output,
int stride) {
void vp9_highbd_fdct8x8_1_c(const int16_t *input, tran_low_t *final_output,
int stride) {
vp9_fdct8x8_1_c(input, final_output, stride);
}
void vp9_high_fdct8x8_c(const int16_t *input, tran_low_t *final_output,
int stride) {
void vp9_highbd_fdct8x8_c(const int16_t *input, tran_low_t *final_output,
int stride) {
vp9_fdct8x8_c(input, final_output, stride);
}
void vp9_high_fdct16x16_1_c(const int16_t *input, tran_low_t *output,
int stride) {
void vp9_highbd_fdct16x16_1_c(const int16_t *input, tran_low_t *output,
int stride) {
vp9_fdct16x16_1_c(input, output, stride);
}
void vp9_high_fdct16x16_c(const int16_t *input, tran_low_t *output,
int stride) {
void vp9_highbd_fdct16x16_c(const int16_t *input, tran_low_t *output,
int stride) {
vp9_fdct16x16_c(input, output, stride);
}
void vp9_high_fht8x8_c(const int16_t *input, tran_low_t *output,
int stride, int tx_type) {
void vp9_highbd_fht8x8_c(const int16_t *input, tran_low_t *output,
int stride, int tx_type) {
vp9_fht8x8_c(input, output, stride, tx_type);
}
void vp9_high_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride) {
void vp9_highbd_fwht4x4_c(const int16_t *input, tran_low_t *output,
int stride) {
vp9_fwht4x4_c(input, output, stride);
}
void vp9_high_fht16x16_c(const int16_t *input, tran_low_t *output,
int stride, int tx_type) {
void vp9_highbd_fht16x16_c(const int16_t *input, tran_low_t *output,
int stride, int tx_type) {
vp9_fht16x16_c(input, output, stride, tx_type);
}
void vp9_high_fdct32x32_1_c(const int16_t *input, tran_low_t *out, int stride) {
void vp9_highbd_fdct32x32_1_c(const int16_t *input, tran_low_t *out,
int stride) {
vp9_fdct32x32_1_c(input, out, stride);
}
void vp9_high_fdct32x32_c(const int16_t *input, tran_low_t *out, int stride) {
void vp9_highbd_fdct32x32_c(const int16_t *input, tran_low_t *out, int stride) {
vp9_fdct32x32_c(input, out, stride);
}
void vp9_high_fdct32x32_rd_c(const int16_t *input, tran_low_t *out,
int stride) {
void vp9_highbd_fdct32x32_rd_c(const int16_t *input, tran_low_t *out,
int stride) {
vp9_fdct32x32_rd_c(input, out, stride);
}
#endif // CONFIG_VP9_HIGHBITDEPTH

15
vp9/encoder/vp9_encodeframe.c
Просмотреть файл

@ -3246,16 +3246,16 @@ static int set_var_thresh_from_histogram(VP9_COMP *cpi) {
if (cm->use_highbitdepth) {
switch (cm->bit_depth) {
case VPX_BITS_8:
vp9_high_get16x16var(src, src_stride, last_src, last_stride,
&var16->sse, &var16->sum);
vp9_highbd_get16x16var(src, src_stride, last_src, last_stride,
&var16->sse, &var16->sum);
break;
case VPX_BITS_10:
vp9_high_10_get16x16var(src, src_stride, last_src, last_stride,
vp9_highbd_10_get16x16var(src, src_stride, last_src, last_stride,
&var16->sse, &var16->sum);
break;
case VPX_BITS_12:
vp9_high_12_get16x16var(src, src_stride, last_src, last_stride,
&var16->sse, &var16->sum);
vp9_highbd_12_get16x16var(src, src_stride, last_src, last_stride,
&var16->sse, &var16->sum);
break;
default:
assert(0 && "cm->bit_depth should be VPX_BITS_8, VPX_BITS_10"
@ -3415,8 +3415,9 @@ static void encode_frame_internal(VP9_COMP *cpi) {
if (cm->use_highbitdepth)
x->fwd_txm4x4 = xd->lossless ? vp9_fwht4x4 : vp9_fdct4x4;
else
x->fwd_txm4x4 = xd->lossless ? vp9_high_fwht4x4 : vp9_high_fdct4x4;
x->high_itxm_add = xd->lossless ? vp9_high_iwht4x4_add : vp9_high_idct4x4_add;
x->fwd_txm4x4 = xd->lossless ? vp9_highbd_fwht4x4 : vp9_highbd_fdct4x4;
x->highbd_itxm_add = xd->lossless ? vp9_highbd_iwht4x4_add :
vp9_highbd_idct4x4_add;
#else
x->fwd_txm4x4 = xd->lossless ? vp9_fwht4x4 : vp9_fdct4x4;
#endif // CONFIG_VP9_HIGHBITDEPTH

224
vp9/encoder/vp9_encodemb.c
Просмотреть файл

@ -52,11 +52,11 @@ void vp9_subtract_block_c(int rows, int cols,
}
#if CONFIG_VP9_HIGHBITDEPTH
void vp9_high_subtract_block_c(int rows, int cols,
int16_t *diff, ptrdiff_t diff_stride,
const uint8_t *src8, ptrdiff_t src_stride,
const uint8_t *pred8, ptrdiff_t pred_stride,
int bd) {
void vp9_highbd_subtract_block_c(int rows, int cols,
int16_t *diff, ptrdiff_t diff_stride,
const uint8_t *src8, ptrdiff_t src_stride,
const uint8_t *pred8, ptrdiff_t pred_stride,
int bd) {
int r, c;
uint16_t *src = CONVERT_TO_SHORTPTR(src8);
uint16_t *pred = CONVERT_TO_SHORTPTR(pred8);
@ -83,8 +83,9 @@ void vp9_subtract_plane(MACROBLOCK *x, BLOCK_SIZE bsize, int plane) {
#if CONFIG_VP9_HIGHBITDEPTH
if (x->e_mbd.cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
vp9_high_subtract_block(bh, bw, p->src_diff, bw, p->src.buf, p->src.stride,
pd->dst.buf, pd->dst.stride, x->e_mbd.bd);
vp9_highbd_subtract_block(bh, bw, p->src_diff, bw, p->src.buf,
p->src.stride, pd->dst.buf, pd->dst.stride,
x->e_mbd.bd);
return;
}
#endif // CONFIG_VP9_HIGHBITDEPTH
@ -363,12 +364,12 @@ static INLINE void fdct32x32(int rd_transform,
}
#if CONFIG_VP9_HIGHBITDEPTH
static INLINE void high_fdct32x32(int rd_transform, const int16_t *src,
tran_low_t *dst, int src_stride) {
static INLINE void highbd_fdct32x32(int rd_transform, const int16_t *src,
tran_low_t *dst, int src_stride) {
if (rd_transform)
vp9_high_fdct32x32_rd(src, dst, src_stride);
vp9_highbd_fdct32x32_rd(src, dst, src_stride);
else
vp9_high_fdct32x32(src, dst, src_stride);
vp9_highbd_fdct32x32(src, dst, src_stride);
}
#endif // CONFIG_VP9_HIGHBITDEPTH
@ -392,32 +393,33 @@ void vp9_xform_quant_fp(MACROBLOCK *x, int plane, int block,
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
switch (tx_size) {
case TX_32X32:
high_fdct32x32(x->use_lp32x32fdct, src_diff, coeff, diff_stride);
vp9_high_quantize_fp_32x32(coeff, 1024, x->skip_block, p->zbin,
p->round_fp, p->quant_fp, p->quant_shift,
qcoeff, dqcoeff, pd->dequant, p->zbin_extra,
eob, scan_order->scan, scan_order->iscan);
highbd_fdct32x32(x->use_lp32x32fdct, src_diff, coeff, diff_stride);
vp9_highbd_quantize_fp_32x32(coeff, 1024, x->skip_block, p->zbin,
p->round_fp, p->quant_fp, p->quant_shift,
qcoeff, dqcoeff, pd->dequant,
p->zbin_extra, eob, scan_order->scan,
scan_order->iscan);
break;
case TX_16X16:
vp9_high_fdct16x16(src_diff, coeff, diff_stride);
vp9_high_quantize_fp(coeff, 256, x->skip_block, p->zbin, p->round_fp,
p->quant_fp, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
vp9_highbd_fdct16x16(src_diff, coeff, diff_stride);
vp9_highbd_quantize_fp(coeff, 256, x->skip_block, p->zbin, p->round_fp,
p->quant_fp, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
break;
case TX_8X8:
vp9_high_fdct8x8(src_diff, coeff, diff_stride);
vp9_high_quantize_fp(coeff, 64, x->skip_block, p->zbin, p->round_fp,
p->quant_fp, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
vp9_highbd_fdct8x8(src_diff, coeff, diff_stride);
vp9_highbd_quantize_fp(coeff, 64, x->skip_block, p->zbin, p->round_fp,
p->quant_fp, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
break;
case TX_4X4:
x->fwd_txm4x4(src_diff, coeff, diff_stride);
vp9_high_quantize_fp(coeff, 16, x->skip_block, p->zbin, p->round_fp,
p->quant_fp, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
vp9_highbd_quantize_fp(coeff, 16, x->skip_block, p->zbin, p->round_fp,
p->quant_fp, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
break;
default:
assert(0);
@ -481,28 +483,28 @@ void vp9_xform_quant_dc(MACROBLOCK *x, int plane, int block,
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
switch (tx_size) {
case TX_32X32:
vp9_high_fdct32x32_1(src_diff, coeff, diff_stride);
vp9_high_quantize_dc_32x32(coeff, x->skip_block, p->round,
p->quant_fp[0], qcoeff, dqcoeff,
pd->dequant[0], eob);
vp9_highbd_fdct32x32_1(src_diff, coeff, diff_stride);
vp9_highbd_quantize_dc_32x32(coeff, x->skip_block, p->round,
p->quant_fp[0], qcoeff, dqcoeff,
pd->dequant[0], eob);
break;
case TX_16X16:
vp9_high_fdct16x16_1(src_diff, coeff, diff_stride);
vp9_high_quantize_dc(coeff, x->skip_block, p->round,
p->quant_fp[0], qcoeff, dqcoeff,
pd->dequant[0], eob);
vp9_highbd_fdct16x16_1(src_diff, coeff, diff_stride);
vp9_highbd_quantize_dc(coeff, x->skip_block, p->round,
p->quant_fp[0], qcoeff, dqcoeff,
pd->dequant[0], eob);
break;
case TX_8X8:
vp9_high_fdct8x8_1(src_diff, coeff, diff_stride);
vp9_high_quantize_dc(coeff, x->skip_block, p->round,
p->quant_fp[0], qcoeff, dqcoeff,
pd->dequant[0], eob);
vp9_highbd_fdct8x8_1(src_diff, coeff, diff_stride);
vp9_highbd_quantize_dc(coeff, x->skip_block, p->round,
p->quant_fp[0], qcoeff, dqcoeff,
pd->dequant[0], eob);
break;
case TX_4X4:
x->fwd_txm4x4(src_diff, coeff, diff_stride);
vp9_high_quantize_dc(coeff, x->skip_block, p->round,
p->quant_fp[0], qcoeff, dqcoeff,
pd->dequant[0], eob);
vp9_highbd_quantize_dc(coeff, x->skip_block, p->round,
p->quant_fp[0], qcoeff, dqcoeff,
pd->dequant[0], eob);
break;
default:
assert(0);
@ -562,32 +564,32 @@ void vp9_xform_quant(MACROBLOCK *x, int plane, int block,
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
switch (tx_size) {
case TX_32X32:
high_fdct32x32(x->use_lp32x32fdct, src_diff, coeff, diff_stride);
vp9_high_quantize_b_32x32(coeff, 1024, x->skip_block, p->zbin,
p->round, p->quant, p->quant_shift, qcoeff,
dqcoeff, pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
highbd_fdct32x32(x->use_lp32x32fdct, src_diff, coeff, diff_stride);
vp9_highbd_quantize_b_32x32(coeff, 1024, x->skip_block, p->zbin,
p->round, p->quant, p->quant_shift, qcoeff,
dqcoeff, pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
break;
case TX_16X16:
vp9_high_fdct16x16(src_diff, coeff, diff_stride);
vp9_high_quantize_b(coeff, 256, x->skip_block, p->zbin, p->round,
p->quant, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
vp9_highbd_fdct16x16(src_diff, coeff, diff_stride);
vp9_highbd_quantize_b(coeff, 256, x->skip_block, p->zbin, p->round,
p->quant, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
break;
case TX_8X8:
vp9_high_fdct8x8(src_diff, coeff, diff_stride);
vp9_high_quantize_b(coeff, 64, x->skip_block, p->zbin, p->round,
p->quant, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
vp9_highbd_fdct8x8(src_diff, coeff, diff_stride);
vp9_highbd_quantize_b(coeff, 64, x->skip_block, p->zbin, p->round,
p->quant, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
break;
case TX_4X4:
x->fwd_txm4x4(src_diff, coeff, diff_stride);
vp9_high_quantize_b(coeff, 16, x->skip_block, p->zbin, p->round,
p->quant, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
vp9_highbd_quantize_b(coeff, 16, x->skip_block, p->zbin, p->round,
p->quant, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
break;
default:
assert(0);
@ -694,23 +696,23 @@ static void encode_block(int plane, int block, BLOCK_SIZE plane_bsize,
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
switch (tx_size) {
case TX_32X32:
vp9_high_idct32x32_add(dqcoeff, dst, pd->dst.stride,
p->eobs[block], xd->bd);
vp9_highbd_idct32x32_add(dqcoeff, dst, pd->dst.stride,
p->eobs[block], xd->bd);
break;
case TX_16X16:
vp9_high_idct16x16_add(dqcoeff, dst, pd->dst.stride,
p->eobs[block], xd->bd);
vp9_highbd_idct16x16_add(dqcoeff, dst, pd->dst.stride,
p->eobs[block], xd->bd);
break;
case TX_8X8:
vp9_high_idct8x8_add(dqcoeff, dst, pd->dst.stride,
p->eobs[block], xd->bd);
vp9_highbd_idct8x8_add(dqcoeff, dst, pd->dst.stride,
p->eobs[block], xd->bd);
break;
case TX_4X4:
// this is like vp9_short_idct4x4 but has a special case around eob<=1
// which is significant (not just an optimization) for the lossless
// case.
x->high_itxm_add(dqcoeff, dst, pd->dst.stride,
p->eobs[block], xd->bd);
x->highbd_itxm_add(dqcoeff, dst, pd->dst.stride,
p->eobs[block], xd->bd);
break;
default:
assert(0 && "Invalid transform size");
@ -758,7 +760,7 @@ static void encode_block_pass1(int plane, int block, BLOCK_SIZE plane_bsize,
if (p->eobs[block] > 0) {
#if CONFIG_VP9_HIGHBITDEPTH
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
x->high_itxm_add(dqcoeff, dst, pd->dst.stride, p->eobs[block], xd->bd);
x->highbd_itxm_add(dqcoeff, dst, pd->dst.stride, p->eobs[block], xd->bd);
return;
}
#endif // CONFIG_VP9_HIGHBITDEPTH
@ -838,16 +840,17 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
x->skip_encode ? src_stride : dst_stride,
dst, dst_stride, i, j, plane);
if (!x->skip_recode) {
vp9_high_subtract_block(32, 32, src_diff, diff_stride,
src, src_stride, dst, dst_stride, xd->bd);
high_fdct32x32(x->use_lp32x32fdct, src_diff, coeff, diff_stride);
vp9_high_quantize_b_32x32(coeff, 1024, x->skip_block, p->zbin,
p->round, p->quant, p->quant_shift, qcoeff,
dqcoeff, pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
vp9_highbd_subtract_block(32, 32, src_diff, diff_stride,
src, src_stride, dst, dst_stride, xd->bd);
highbd_fdct32x32(x->use_lp32x32fdct, src_diff, coeff, diff_stride);
vp9_highbd_quantize_b_32x32(coeff, 1024, x->skip_block, p->zbin,
p->round, p->quant, p->quant_shift,
qcoeff, dqcoeff, pd->dequant,
p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
}
if (!x->skip_encode && *eob) {
vp9_high_idct32x32_add(dqcoeff, dst, dst_stride, *eob, xd->bd);
vp9_highbd_idct32x32_add(dqcoeff, dst, dst_stride, *eob, xd->bd);
}
break;
case TX_16X16:
@ -859,17 +862,17 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
x->skip_encode ? src_stride : dst_stride,
dst, dst_stride, i, j, plane);
if (!x->skip_recode) {
vp9_high_subtract_block(16, 16, src_diff, diff_stride,
src, src_stride, dst, dst_stride, xd->bd);
vp9_high_fht16x16(src_diff, coeff, diff_stride, tx_type);
vp9_high_quantize_b(coeff, 256, x->skip_block, p->zbin, p->round,
p->quant, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
vp9_highbd_subtract_block(16, 16, src_diff, diff_stride,
src, src_stride, dst, dst_stride, xd->bd);
vp9_highbd_fht16x16(src_diff, coeff, diff_stride, tx_type);
vp9_highbd_quantize_b(coeff, 256, x->skip_block, p->zbin, p->round,
p->quant, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
}
if (!x->skip_encode && *eob) {
vp9_high_iht16x16_add(tx_type, dqcoeff, dst, dst_stride,
*eob, xd->bd);
vp9_highbd_iht16x16_add(tx_type, dqcoeff, dst, dst_stride,
*eob, xd->bd);
}
break;
case TX_8X8:
@ -881,17 +884,17 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
x->skip_encode ? src_stride : dst_stride,
dst, dst_stride, i, j, plane);
if (!x->skip_recode) {
vp9_high_subtract_block(8, 8, src_diff, diff_stride,
src, src_stride, dst, dst_stride, xd->bd);
vp9_high_fht8x8(src_diff, coeff, diff_stride, tx_type);
vp9_high_quantize_b(coeff, 64, x->skip_block, p->zbin, p->round,
p->quant, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
vp9_highbd_subtract_block(8, 8, src_diff, diff_stride,
src, src_stride, dst, dst_stride, xd->bd);
vp9_highbd_fht8x8(src_diff, coeff, diff_stride, tx_type);
vp9_highbd_quantize_b(coeff, 64, x->skip_block, p->zbin, p->round,
p->quant, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
}
if (!x->skip_encode && *eob) {
vp9_high_iht8x8_add(tx_type, dqcoeff, dst, dst_stride, *eob,
xd->bd);
vp9_highbd_iht8x8_add(tx_type, dqcoeff, dst, dst_stride, *eob,
xd->bd);
}
break;
case TX_4X4:
@ -904,26 +907,27 @@ static void encode_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
dst, dst_stride, i, j, plane);
if (!x->skip_recode) {
vp9_high_subtract_block(4, 4, src_diff, diff_stride,
src, src_stride, dst, dst_stride, xd->bd);
vp9_highbd_subtract_block(4, 4, src_diff, diff_stride,
src, src_stride, dst, dst_stride, xd->bd);
if (tx_type != DCT_DCT)
vp9_high_fht4x4(src_diff, coeff, diff_stride, tx_type);
vp9_highbd_fht4x4(src_diff, coeff, diff_stride, tx_type);
else
x->fwd_txm4x4(src_diff, coeff, diff_stride);
vp9_high_quantize_b(coeff, 16, x->skip_block, p->zbin, p->round,
p->quant, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
vp9_highbd_quantize_b(coeff, 16, x->skip_block, p->zbin, p->round,
p->quant, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, p->zbin_extra, eob,
scan_order->scan, scan_order->iscan);
}
if (!x->skip_encode && *eob) {
if (tx_type == DCT_DCT)
if (tx_type == DCT_DCT) {
// this is like vp9_short_idct4x4 but has a special case around
// eob<=1 which is significant (not just an optimization) for the
// lossless case.
x->high_itxm_add(dqcoeff, dst, dst_stride, *eob, xd->bd);
else
vp9_high_iht4x4_16_add(dqcoeff, dst, dst_stride, tx_type, xd->bd);
x->highbd_itxm_add(dqcoeff, dst, dst_stride, *eob, xd->bd);
} else {
vp9_highbd_iht4x4_16_add(dqcoeff, dst, dst_stride, tx_type, xd->bd);
}
}
break;
default:

714
vp9/encoder/vp9_encoder.c
Просмотреть файл

@ -745,460 +745,460 @@ static void fnname##_bits12(const uint8_t *src_ptr, \
sad_array[i] >>= 4; \
}
MAKE_BFP_SAD_WRAPPER(vp9_high_sad32x16)
MAKE_BFP_SADAVG_WRAPPER(vp9_high_sad32x16_avg)
MAKE_BFP_SAD4D_WRAPPER(vp9_high_sad32x16x4d)
MAKE_BFP_SAD_WRAPPER(vp9_high_sad16x32)
MAKE_BFP_SADAVG_WRAPPER(vp9_high_sad16x32_avg)
MAKE_BFP_SAD4D_WRAPPER(vp9_high_sad16x32x4d)
MAKE_BFP_SAD_WRAPPER(vp9_high_sad64x32)
MAKE_BFP_SADAVG_WRAPPER(vp9_high_sad64x32_avg)
MAKE_BFP_SAD4D_WRAPPER(vp9_high_sad64x32x4d)
MAKE_BFP_SAD_WRAPPER(vp9_high_sad32x64)
MAKE_BFP_SADAVG_WRAPPER(vp9_high_sad32x64_avg)
MAKE_BFP_SAD4D_WRAPPER(vp9_high_sad32x64x4d)
MAKE_BFP_SAD_WRAPPER(vp9_high_sad32x32)
MAKE_BFP_SADAVG_WRAPPER(vp9_high_sad32x32_avg)
MAKE_BFP_SAD3_WRAPPER(vp9_high_sad32x32x3)
MAKE_BFP_SAD8_WRAPPER(vp9_high_sad32x32x8)
MAKE_BFP_SAD4D_WRAPPER(vp9_high_sad32x32x4d)
MAKE_BFP_SAD_WRAPPER(vp9_high_sad64x64)
MAKE_BFP_SADAVG_WRAPPER(vp9_high_sad64x64_avg)
MAKE_BFP_SAD3_WRAPPER(vp9_high_sad64x64x3)
MAKE_BFP_SAD8_WRAPPER(vp9_high_sad64x64x8)
MAKE_BFP_SAD4D_WRAPPER(vp9_high_sad64x64x4d)
MAKE_BFP_SAD_WRAPPER(vp9_high_sad16x16)
MAKE_BFP_SADAVG_WRAPPER(vp9_high_sad16x16_avg)
MAKE_BFP_SAD3_WRAPPER(vp9_high_sad16x16x3)
MAKE_BFP_SAD8_WRAPPER(vp9_high_sad16x16x8)
MAKE_BFP_SAD4D_WRAPPER(vp9_high_sad16x16x4d)
MAKE_BFP_SAD_WRAPPER(vp9_high_sad16x8)
MAKE_BFP_SADAVG_WRAPPER(vp9_high_sad16x8_avg)
MAKE_BFP_SAD3_WRAPPER(vp9_high_sad16x8x3)
MAKE_BFP_SAD8_WRAPPER(vp9_high_sad16x8x8)
MAKE_BFP_SAD4D_WRAPPER(vp9_high_sad16x8x4d)
MAKE_BFP_SAD_WRAPPER(vp9_high_sad8x16)
MAKE_BFP_SADAVG_WRAPPER(vp9_high_sad8x16_avg)
MAKE_BFP_SAD3_WRAPPER(vp9_high_sad8x16x3)
MAKE_BFP_SAD8_WRAPPER(vp9_high_sad8x16x8)
MAKE_BFP_SAD4D_WRAPPER(vp9_high_sad8x16x4d)
MAKE_BFP_SAD_WRAPPER(vp9_high_sad8x8)
MAKE_BFP_SADAVG_WRAPPER(vp9_high_sad8x8_avg)
MAKE_BFP_SAD3_WRAPPER(vp9_high_sad8x8x3)
MAKE_BFP_SAD8_WRAPPER(vp9_high_sad8x8x8)
MAKE_BFP_SAD4D_WRAPPER(vp9_high_sad8x8x4d)
MAKE_BFP_SAD_WRAPPER(vp9_high_sad8x4)
MAKE_BFP_SADAVG_WRAPPER(vp9_high_sad8x4_avg)
MAKE_BFP_SAD8_WRAPPER(vp9_high_sad8x4x8)
MAKE_BFP_SAD4D_WRAPPER(vp9_high_sad8x4x4d)
MAKE_BFP_SAD_WRAPPER(vp9_high_sad4x8)
MAKE_BFP_SADAVG_WRAPPER(vp9_high_sad4x8_avg)
MAKE_BFP_SAD8_WRAPPER(vp9_high_sad4x8x8)
MAKE_BFP_SAD4D_WRAPPER(vp9_high_sad4x8x4d)
MAKE_BFP_SAD_WRAPPER(vp9_high_sad4x4)
MAKE_BFP_SADAVG_WRAPPER(vp9_high_sad4x4_avg)
MAKE_BFP_SAD3_WRAPPER(vp9_high_sad4x4x3)
MAKE_BFP_SAD8_WRAPPER(vp9_high_sad4x4x8)
MAKE_BFP_SAD4D_WRAPPER(vp9_high_sad4x4x4d)
MAKE_BFP_SAD_WRAPPER(vp9_highbd_sad32x16)
MAKE_BFP_SADAVG_WRAPPER(vp9_highbd_sad32x16_avg)
MAKE_BFP_SAD4D_WRAPPER(vp9_highbd_sad32x16x4d)
MAKE_BFP_SAD_WRAPPER(vp9_highbd_sad16x32)
MAKE_BFP_SADAVG_WRAPPER(vp9_highbd_sad16x32_avg)
MAKE_BFP_SAD4D_WRAPPER(vp9_highbd_sad16x32x4d)
MAKE_BFP_SAD_WRAPPER(vp9_highbd_sad64x32)
MAKE_BFP_SADAVG_WRAPPER(vp9_highbd_sad64x32_avg)
MAKE_BFP_SAD4D_WRAPPER(vp9_highbd_sad64x32x4d)
MAKE_BFP_SAD_WRAPPER(vp9_highbd_sad32x64)
MAKE_BFP_SADAVG_WRAPPER(vp9_highbd_sad32x64_avg)
MAKE_BFP_SAD4D_WRAPPER(vp9_highbd_sad32x64x4d)
MAKE_BFP_SAD_WRAPPER(vp9_highbd_sad32x32)
MAKE_BFP_SADAVG_WRAPPER(vp9_highbd_sad32x32_avg)
MAKE_BFP_SAD3_WRAPPER(vp9_highbd_sad32x32x3)
MAKE_BFP_SAD8_WRAPPER(vp9_highbd_sad32x32x8)
MAKE_BFP_SAD4D_WRAPPER(vp9_highbd_sad32x32x4d)
MAKE_BFP_SAD_WRAPPER(vp9_highbd_sad64x64)
MAKE_BFP_SADAVG_WRAPPER(vp9_highbd_sad64x64_avg)
MAKE_BFP_SAD3_WRAPPER(vp9_highbd_sad64x64x3)
MAKE_BFP_SAD8_WRAPPER(vp9_highbd_sad64x64x8)
MAKE_BFP_SAD4D_WRAPPER(vp9_highbd_sad64x64x4d)
MAKE_BFP_SAD_WRAPPER(vp9_highbd_sad16x16)
MAKE_BFP_SADAVG_WRAPPER(vp9_highbd_sad16x16_avg)
MAKE_BFP_SAD3_WRAPPER(vp9_highbd_sad16x16x3)
MAKE_BFP_SAD8_WRAPPER(vp9_highbd_sad16x16x8)
MAKE_BFP_SAD4D_WRAPPER(vp9_highbd_sad16x16x4d)
MAKE_BFP_SAD_WRAPPER(vp9_highbd_sad16x8)
MAKE_BFP_SADAVG_WRAPPER(vp9_highbd_sad16x8_avg)
MAKE_BFP_SAD3_WRAPPER(vp9_highbd_sad16x8x3)
MAKE_BFP_SAD8_WRAPPER(vp9_highbd_sad16x8x8)
MAKE_BFP_SAD4D_WRAPPER(vp9_highbd_sad16x8x4d)
MAKE_BFP_SAD_WRAPPER(vp9_highbd_sad8x16)
MAKE_BFP_SADAVG_WRAPPER(vp9_highbd_sad8x16_avg)
MAKE_BFP_SAD3_WRAPPER(vp9_highbd_sad8x16x3)
MAKE_BFP_SAD8_WRAPPER(vp9_highbd_sad8x16x8)
MAKE_BFP_SAD4D_WRAPPER(vp9_highbd_sad8x16x4d)
MAKE_BFP_SAD_WRAPPER(vp9_highbd_sad8x8)
MAKE_BFP_SADAVG_WRAPPER(vp9_highbd_sad8x8_avg)
MAKE_BFP_SAD3_WRAPPER(vp9_highbd_sad8x8x3)
MAKE_BFP_SAD8_WRAPPER(vp9_highbd_sad8x8x8)
MAKE_BFP_SAD4D_WRAPPER(vp9_highbd_sad8x8x4d)
MAKE_BFP_SAD_WRAPPER(vp9_highbd_sad8x4)
MAKE_BFP_SADAVG_WRAPPER(vp9_highbd_sad8x4_avg)
MAKE_BFP_SAD8_WRAPPER(vp9_highbd_sad8x4x8)
MAKE_BFP_SAD4D_WRAPPER(vp9_highbd_sad8x4x4d)
MAKE_BFP_SAD_WRAPPER(vp9_highbd_sad4x8)
MAKE_BFP_SADAVG_WRAPPER(vp9_highbd_sad4x8_avg)
MAKE_BFP_SAD8_WRAPPER(vp9_highbd_sad4x8x8)
MAKE_BFP_SAD4D_WRAPPER(vp9_highbd_sad4x8x4d)
MAKE_BFP_SAD_WRAPPER(vp9_highbd_sad4x4)
MAKE_BFP_SADAVG_WRAPPER(vp9_highbd_sad4x4_avg)
MAKE_BFP_SAD3_WRAPPER(vp9_highbd_sad4x4x3)
MAKE_BFP_SAD8_WRAPPER(vp9_highbd_sad4x4x8)
MAKE_BFP_SAD4D_WRAPPER(vp9_highbd_sad4x4x4d)
static void highbd_set_var_fns(VP9_COMP *const cpi) {
static void highbd_set_var_fns(VP9_COMP *const cpi) {
VP9_COMMON *const cm = &cpi->common;
if (cm->use_highbitdepth) {
switch (cm->bit_depth) {
case VPX_BITS_8:
HIGHBD_BFP(BLOCK_32X16,
vp9_high_sad32x16_bits8,
vp9_high_sad32x16_avg_bits8,
vp9_high_variance32x16,
vp9_high_sub_pixel_variance32x16,
vp9_high_sub_pixel_avg_variance32x16,
vp9_highbd_sad32x16_bits8,
vp9_highbd_sad32x16_avg_bits8,
vp9_highbd_variance32x16,
vp9_highbd_sub_pixel_variance32x16,
vp9_highbd_sub_pixel_avg_variance32x16,
NULL,
NULL,
vp9_high_sad32x16x4d_bits8)
vp9_highbd_sad32x16x4d_bits8)
HIGHBD_BFP(BLOCK_16X32,
vp9_high_sad16x32_bits8,
vp9_high_sad16x32_avg_bits8,
vp9_high_variance16x32,
vp9_high_sub_pixel_variance16x32,
vp9_high_sub_pixel_avg_variance16x32,
vp9_highbd_sad16x32_bits8,
vp9_highbd_sad16x32_avg_bits8,
vp9_highbd_variance16x32,
vp9_highbd_sub_pixel_variance16x32,
vp9_highbd_sub_pixel_avg_variance16x32,
NULL,
NULL,
vp9_high_sad16x32x4d_bits8)
vp9_highbd_sad16x32x4d_bits8)
HIGHBD_BFP(BLOCK_64X32,
vp9_high_sad64x32_bits8,
vp9_high_sad64x32_avg_bits8,
vp9_high_variance64x32,
vp9_high_sub_pixel_variance64x32,
vp9_high_sub_pixel_avg_variance64x32,
vp9_highbd_sad64x32_bits8,
vp9_highbd_sad64x32_avg_bits8,
vp9_highbd_variance64x32,
vp9_highbd_sub_pixel_variance64x32,
vp9_highbd_sub_pixel_avg_variance64x32,
NULL,
NULL,
vp9_high_sad64x32x4d_bits8)
vp9_highbd_sad64x32x4d_bits8)
HIGHBD_BFP(BLOCK_32X64,
vp9_high_sad32x64_bits8,
vp9_high_sad32x64_avg_bits8,
vp9_high_variance32x64,
vp9_high_sub_pixel_variance32x64,
vp9_high_sub_pixel_avg_variance32x64,
vp9_highbd_sad32x64_bits8,
vp9_highbd_sad32x64_avg_bits8,
vp9_highbd_variance32x64,
vp9_highbd_sub_pixel_variance32x64,
vp9_highbd_sub_pixel_avg_variance32x64,
NULL,
NULL,
vp9_high_sad32x64x4d_bits8)
vp9_highbd_sad32x64x4d_bits8)
HIGHBD_BFP(BLOCK_32X32,
vp9_high_sad32x32_bits8,
vp9_high_sad32x32_avg_bits8,
vp9_high_variance32x32,
vp9_high_sub_pixel_variance32x32,
vp9_high_sub_pixel_avg_variance32x32,
vp9_high_sad32x32x3_bits8,
vp9_high_sad32x32x8_bits8,
vp9_high_sad32x32x4d_bits8)
vp9_highbd_sad32x32_bits8,
vp9_highbd_sad32x32_avg_bits8,
vp9_highbd_variance32x32,
vp9_highbd_sub_pixel_variance32x32,
vp9_highbd_sub_pixel_avg_variance32x32,
vp9_highbd_sad32x32x3_bits8,
vp9_highbd_sad32x32x8_bits8,
vp9_highbd_sad32x32x4d_bits8)
HIGHBD_BFP(BLOCK_64X64,
vp9_high_sad64x64_bits8,
vp9_high_sad64x64_avg_bits8,
vp9_high_variance64x64,
vp9_high_sub_pixel_variance64x64,
vp9_high_sub_pixel_avg_variance64x64,
vp9_high_sad64x64x3_bits8,
vp9_high_sad64x64x8_bits8,
vp9_high_sad64x64x4d_bits8)
vp9_highbd_sad64x64_bits8,
vp9_highbd_sad64x64_avg_bits8,
vp9_highbd_variance64x64,
vp9_highbd_sub_pixel_variance64x64,
vp9_highbd_sub_pixel_avg_variance64x64,
vp9_highbd_sad64x64x3_bits8,
vp9_highbd_sad64x64x8_bits8,
vp9_highbd_sad64x64x4d_bits8)
HIGHBD_BFP(BLOCK_16X16,
vp9_high_sad16x16_bits8,
vp9_high_sad16x16_avg_bits8,
vp9_high_variance16x16,
vp9_high_sub_pixel_variance16x16,
vp9_high_sub_pixel_avg_variance16x16,
vp9_high_sad16x16x3_bits8,
vp9_high_sad16x16x8_bits8,
vp9_high_sad16x16x4d_bits8)
vp9_highbd_sad16x16_bits8,
vp9_highbd_sad16x16_avg_bits8,
vp9_highbd_variance16x16,
vp9_highbd_sub_pixel_variance16x16,
vp9_highbd_sub_pixel_avg_variance16x16,
vp9_highbd_sad16x16x3_bits8,
vp9_highbd_sad16x16x8_bits8,
vp9_highbd_sad16x16x4d_bits8)
HIGHBD_BFP(BLOCK_16X8,
vp9_high_sad16x8_bits8,
vp9_high_sad16x8_avg_bits8,
vp9_high_variance16x8,
vp9_high_sub_pixel_variance16x8,
vp9_high_sub_pixel_avg_variance16x8,
vp9_high_sad16x8x3_bits8,
vp9_high_sad16x8x8_bits8,
vp9_high_sad16x8x4d_bits8)
vp9_highbd_sad16x8_bits8,
vp9_highbd_sad16x8_avg_bits8,
vp9_highbd_variance16x8,
vp9_highbd_sub_pixel_variance16x8,
vp9_highbd_sub_pixel_avg_variance16x8,
vp9_highbd_sad16x8x3_bits8,
vp9_highbd_sad16x8x8_bits8,
vp9_highbd_sad16x8x4d_bits8)
HIGHBD_BFP(BLOCK_8X16,
vp9_high_sad8x16_bits8,
vp9_high_sad8x16_avg_bits8,
vp9_high_variance8x16,
vp9_high_sub_pixel_variance8x16,
vp9_high_sub_pixel_avg_variance8x16,
vp9_high_sad8x16x3_bits8,
vp9_high_sad8x16x8_bits8,
vp9_high_sad8x16x4d_bits8)
vp9_highbd_sad8x16_bits8,
vp9_highbd_sad8x16_avg_bits8,
vp9_highbd_variance8x16,
vp9_highbd_sub_pixel_variance8x16,
vp9_highbd_sub_pixel_avg_variance8x16,
vp9_highbd_sad8x16x3_bits8,
vp9_highbd_sad8x16x8_bits8,
vp9_highbd_sad8x16x4d_bits8)
HIGHBD_BFP(BLOCK_8X8,
vp9_high_sad8x8_bits8,
vp9_high_sad8x8_avg_bits8,
vp9_high_variance8x8,
vp9_high_sub_pixel_variance8x8,
vp9_high_sub_pixel_avg_variance8x8,
vp9_high_sad8x8x3_bits8,
vp9_high_sad8x8x8_bits8,
vp9_high_sad8x8x4d_bits8)
vp9_highbd_sad8x8_bits8,
vp9_highbd_sad8x8_avg_bits8,
vp9_highbd_variance8x8,
vp9_highbd_sub_pixel_variance8x8,
vp9_highbd_sub_pixel_avg_variance8x8,
vp9_highbd_sad8x8x3_bits8,
vp9_highbd_sad8x8x8_bits8,
vp9_highbd_sad8x8x4d_bits8)
HIGHBD_BFP(BLOCK_8X4,
vp9_high_sad8x4_bits8,
vp9_high_sad8x4_avg_bits8,
vp9_high_variance8x4,
vp9_high_sub_pixel_variance8x4,
vp9_high_sub_pixel_avg_variance8x4,
vp9_highbd_sad8x4_bits8,
vp9_highbd_sad8x4_avg_bits8,
vp9_highbd_variance8x4,
vp9_highbd_sub_pixel_variance8x4,
vp9_highbd_sub_pixel_avg_variance8x4,
NULL,
vp9_high_sad8x4x8_bits8,
vp9_high_sad8x4x4d_bits8)
vp9_highbd_sad8x4x8_bits8,
vp9_highbd_sad8x4x4d_bits8)
HIGHBD_BFP(BLOCK_4X8,
vp9_high_sad4x8_bits8,
vp9_high_sad4x8_avg_bits8,
vp9_high_variance4x8,
vp9_high_sub_pixel_variance4x8,
vp9_high_sub_pixel_avg_variance4x8,
vp9_highbd_sad4x8_bits8,
vp9_highbd_sad4x8_avg_bits8,
vp9_highbd_variance4x8,
vp9_highbd_sub_pixel_variance4x8,
vp9_highbd_sub_pixel_avg_variance4x8,
NULL,
vp9_high_sad4x8x8_bits8,
vp9_high_sad4x8x4d_bits8)
vp9_highbd_sad4x8x8_bits8,
vp9_highbd_sad4x8x4d_bits8)
HIGHBD_BFP(BLOCK_4X4,
vp9_high_sad4x4_bits8,
vp9_high_sad4x4_avg_bits8,
vp9_high_variance4x4,
vp9_high_sub_pixel_variance4x4,
vp9_high_sub_pixel_avg_variance4x4,
vp9_high_sad4x4x3_bits8,
vp9_high_sad4x4x8_bits8,
vp9_high_sad4x4x4d_bits8)
vp9_highbd_sad4x4_bits8,
vp9_highbd_sad4x4_avg_bits8,
vp9_highbd_variance4x4,
vp9_highbd_sub_pixel_variance4x4,
vp9_highbd_sub_pixel_avg_variance4x4,
vp9_highbd_sad4x4x3_bits8,
vp9_highbd_sad4x4x8_bits8,
vp9_highbd_sad4x4x4d_bits8)
break;
case VPX_BITS_10:
HIGHBD_BFP(BLOCK_32X16,
vp9_high_sad32x16_bits10,
vp9_high_sad32x16_avg_bits10,
vp9_high_10_variance32x16,
vp9_high_10_sub_pixel_variance32x16,
vp9_high_10_sub_pixel_avg_variance32x16,
vp9_highbd_sad32x16_bits10,
vp9_highbd_sad32x16_avg_bits10,
vp9_highbd_10_variance32x16,
vp9_highbd_10_sub_pixel_variance32x16,
vp9_highbd_10_sub_pixel_avg_variance32x16,
NULL,
NULL,
vp9_high_sad32x16x4d_bits10)
vp9_highbd_sad32x16x4d_bits10)
HIGHBD_BFP(BLOCK_16X32,
vp9_high_sad16x32_bits10,
vp9_high_sad16x32_avg_bits10,
vp9_high_10_variance16x32,
vp9_high_10_sub_pixel_variance16x32,
vp9_high_10_sub_pixel_avg_variance16x32,
vp9_highbd_sad16x32_bits10,
vp9_highbd_sad16x32_avg_bits10,
vp9_highbd_10_variance16x32,
vp9_highbd_10_sub_pixel_variance16x32,
vp9_highbd_10_sub_pixel_avg_variance16x32,
NULL,
NULL,
vp9_high_sad16x32x4d_bits10)
vp9_highbd_sad16x32x4d_bits10)
HIGHBD_BFP(BLOCK_64X32,
vp9_high_sad64x32_bits10,
vp9_high_sad64x32_avg_bits10,
vp9_high_10_variance64x32,
vp9_high_10_sub_pixel_variance64x32,
vp9_high_10_sub_pixel_avg_variance64x32,
vp9_highbd_sad64x32_bits10,
vp9_highbd_sad64x32_avg_bits10,
vp9_highbd_10_variance64x32,
vp9_highbd_10_sub_pixel_variance64x32,
vp9_highbd_10_sub_pixel_avg_variance64x32,
NULL,
NULL,
vp9_high_sad64x32x4d_bits10)
vp9_highbd_sad64x32x4d_bits10)
HIGHBD_BFP(BLOCK_32X64,
vp9_high_sad32x64_bits10,
vp9_high_sad32x64_avg_bits10,
vp9_high_10_variance32x64,
vp9_high_10_sub_pixel_variance32x64,
vp9_high_10_sub_pixel_avg_variance32x64,
vp9_highbd_sad32x64_bits10,
vp9_highbd_sad32x64_avg_bits10,
vp9_highbd_10_variance32x64,
vp9_highbd_10_sub_pixel_variance32x64,
vp9_highbd_10_sub_pixel_avg_variance32x64,
NULL,
NULL,
vp9_high_sad32x64x4d_bits10)
vp9_highbd_sad32x64x4d_bits10)
HIGHBD_BFP(BLOCK_32X32,
vp9_high_sad32x32_bits10,
vp9_high_sad32x32_avg_bits10,
vp9_high_10_variance32x32,
vp9_high_10_sub_pixel_variance32x32,
vp9_high_10_sub_pixel_avg_variance32x32,
vp9_high_sad32x32x3_bits10,
vp9_high_sad32x32x8_bits10,
vp9_high_sad32x32x4d_bits10)
vp9_highbd_sad32x32_bits10,
vp9_highbd_sad32x32_avg_bits10,
vp9_highbd_10_variance32x32,
vp9_highbd_10_sub_pixel_variance32x32,
vp9_highbd_10_sub_pixel_avg_variance32x32,
vp9_highbd_sad32x32x3_bits10,
vp9_highbd_sad32x32x8_bits10,
vp9_highbd_sad32x32x4d_bits10)
HIGHBD_BFP(BLOCK_64X64,
vp9_high_sad64x64_bits10,
vp9_high_sad64x64_avg_bits10,
vp9_high_10_variance64x64,
vp9_high_10_sub_pixel_variance64x64,
vp9_high_10_sub_pixel_avg_variance64x64,
vp9_high_sad64x64x3_bits10,
vp9_high_sad64x64x8_bits10,
vp9_high_sad64x64x4d_bits10)
vp9_highbd_sad64x64_bits10,
vp9_highbd_sad64x64_avg_bits10,
vp9_highbd_10_variance64x64,
vp9_highbd_10_sub_pixel_variance64x64,
vp9_highbd_10_sub_pixel_avg_variance64x64,
vp9_highbd_sad64x64x3_bits10,
vp9_highbd_sad64x64x8_bits10,
vp9_highbd_sad64x64x4d_bits10)
HIGHBD_BFP(BLOCK_16X16,
vp9_high_sad16x16_bits10,
vp9_high_sad16x16_avg_bits10,
vp9_high_10_variance16x16,
vp9_high_10_sub_pixel_variance16x16,
vp9_high_10_sub_pixel_avg_variance16x16,
vp9_high_sad16x16x3_bits10,
vp9_high_sad16x16x8_bits10,
vp9_high_sad16x16x4d_bits10)
vp9_highbd_sad16x16_bits10,
vp9_highbd_sad16x16_avg_bits10,
vp9_highbd_10_variance16x16,
vp9_highbd_10_sub_pixel_variance16x16,
vp9_highbd_10_sub_pixel_avg_variance16x16,
vp9_highbd_sad16x16x3_bits10,
vp9_highbd_sad16x16x8_bits10,
vp9_highbd_sad16x16x4d_bits10)
HIGHBD_BFP(BLOCK_16X8,
vp9_high_sad16x8_bits10,
vp9_high_sad16x8_avg_bits10,
vp9_high_10_variance16x8,
vp9_high_10_sub_pixel_variance16x8,
vp9_high_10_sub_pixel_avg_variance16x8,
vp9_high_sad16x8x3_bits10,
vp9_high_sad16x8x8_bits10,
vp9_high_sad16x8x4d_bits10)
vp9_highbd_sad16x8_bits10,
vp9_highbd_sad16x8_avg_bits10,
vp9_highbd_10_variance16x8,
vp9_highbd_10_sub_pixel_variance16x8,
vp9_highbd_10_sub_pixel_avg_variance16x8,
vp9_highbd_sad16x8x3_bits10,
vp9_highbd_sad16x8x8_bits10,
vp9_highbd_sad16x8x4d_bits10)
HIGHBD_BFP(BLOCK_8X16,
vp9_high_sad8x16_bits10,
vp9_high_sad8x16_avg_bits10,
vp9_high_10_variance8x16,
vp9_high_10_sub_pixel_variance8x16,
vp9_high_10_sub_pixel_avg_variance8x16,
vp9_high_sad8x16x3_bits10,
vp9_high_sad8x16x8_bits10,
vp9_high_sad8x16x4d_bits10)
vp9_highbd_sad8x16_bits10,
vp9_highbd_sad8x16_avg_bits10,
vp9_highbd_10_variance8x16,
vp9_highbd_10_sub_pixel_variance8x16,
vp9_highbd_10_sub_pixel_avg_variance8x16,
vp9_highbd_sad8x16x3_bits10,
vp9_highbd_sad8x16x8_bits10,
vp9_highbd_sad8x16x4d_bits10)
HIGHBD_BFP(BLOCK_8X8,
vp9_high_sad8x8_bits10,
vp9_high_sad8x8_avg_bits10,
vp9_high_10_variance8x8,
vp9_high_10_sub_pixel_variance8x8,
vp9_high_10_sub_pixel_avg_variance8x8,
vp9_high_sad8x8x3_bits10,
vp9_high_sad8x8x8_bits10,
vp9_high_sad8x8x4d_bits10)
vp9_highbd_sad8x8_bits10,
vp9_highbd_sad8x8_avg_bits10,
vp9_highbd_10_variance8x8,
vp9_highbd_10_sub_pixel_variance8x8,
vp9_highbd_10_sub_pixel_avg_variance8x8,
vp9_highbd_sad8x8x3_bits10,
vp9_highbd_sad8x8x8_bits10,
vp9_highbd_sad8x8x4d_bits10)
HIGHBD_BFP(BLOCK_8X4,
vp9_high_sad8x4_bits10,
vp9_high_sad8x4_avg_bits10,
vp9_high_10_variance8x4,
vp9_high_10_sub_pixel_variance8x4,
vp9_high_10_sub_pixel_avg_variance8x4,
vp9_highbd_sad8x4_bits10,
vp9_highbd_sad8x4_avg_bits10,
vp9_highbd_10_variance8x4,
vp9_highbd_10_sub_pixel_variance8x4,
vp9_highbd_10_sub_pixel_avg_variance8x4,
NULL,
vp9_high_sad8x4x8_bits10,
vp9_high_sad8x4x4d_bits10)
vp9_highbd_sad8x4x8_bits10,
vp9_highbd_sad8x4x4d_bits10)
HIGHBD_BFP(BLOCK_4X8,
vp9_high_sad4x8_bits10,
vp9_high_sad4x8_avg_bits10,
vp9_high_10_variance4x8,
vp9_high_10_sub_pixel_variance4x8,
vp9_high_10_sub_pixel_avg_variance4x8,
vp9_highbd_sad4x8_bits10,
vp9_highbd_sad4x8_avg_bits10,
vp9_highbd_10_variance4x8,
vp9_highbd_10_sub_pixel_variance4x8,
vp9_highbd_10_sub_pixel_avg_variance4x8,
NULL,
vp9_high_sad4x8x8_bits10,
vp9_high_sad4x8x4d_bits10)
vp9_highbd_sad4x8x8_bits10,
vp9_highbd_sad4x8x4d_bits10)
HIGHBD_BFP(BLOCK_4X4,
vp9_high_sad4x4_bits10,
vp9_high_sad4x4_avg_bits10,
vp9_high_10_variance4x4,
vp9_high_10_sub_pixel_variance4x4,
vp9_high_10_sub_pixel_avg_variance4x4,
vp9_high_sad4x4x3_bits10,
vp9_high_sad4x4x8_bits10,
vp9_high_sad4x4x4d_bits10)
vp9_highbd_sad4x4_bits10,
vp9_highbd_sad4x4_avg_bits10,
vp9_highbd_10_variance4x4,
vp9_highbd_10_sub_pixel_variance4x4,
vp9_highbd_10_sub_pixel_avg_variance4x4,
vp9_highbd_sad4x4x3_bits10,
vp9_highbd_sad4x4x8_bits10,
vp9_highbd_sad4x4x4d_bits10)
break;
case VPX_BITS_12:
HIGHBD_BFP(BLOCK_32X16,
vp9_high_sad32x16_bits12,
vp9_high_sad32x16_avg_bits12,
vp9_high_12_variance32x16,
vp9_high_12_sub_pixel_variance32x16,
vp9_high_12_sub_pixel_avg_variance32x16,
vp9_highbd_sad32x16_bits12,
vp9_highbd_sad32x16_avg_bits12,
vp9_highbd_12_variance32x16,
vp9_highbd_12_sub_pixel_variance32x16,
vp9_highbd_12_sub_pixel_avg_variance32x16,
NULL,
NULL,
vp9_high_sad32x16x4d_bits12)
vp9_highbd_sad32x16x4d_bits12)
HIGHBD_BFP(BLOCK_16X32,
vp9_high_sad16x32_bits12,
vp9_high_sad16x32_avg_bits12,
vp9_high_12_variance16x32,
vp9_high_12_sub_pixel_variance16x32,
vp9_high_12_sub_pixel_avg_variance16x32,
vp9_highbd_sad16x32_bits12,
vp9_highbd_sad16x32_avg_bits12,
vp9_highbd_12_variance16x32,
vp9_highbd_12_sub_pixel_variance16x32,
vp9_highbd_12_sub_pixel_avg_variance16x32,
NULL,
NULL,
vp9_high_sad16x32x4d_bits12)
vp9_highbd_sad16x32x4d_bits12)
HIGHBD_BFP(BLOCK_64X32,
vp9_high_sad64x32_bits12,
vp9_high_sad64x32_avg_bits12,
vp9_high_12_variance64x32,
vp9_high_12_sub_pixel_variance64x32,
vp9_high_12_sub_pixel_avg_variance64x32,
vp9_highbd_sad64x32_bits12,
vp9_highbd_sad64x32_avg_bits12,
vp9_highbd_12_variance64x32,
vp9_highbd_12_sub_pixel_variance64x32,
vp9_highbd_12_sub_pixel_avg_variance64x32,
NULL,
NULL,
vp9_high_sad64x32x4d_bits12)
vp9_highbd_sad64x32x4d_bits12)
HIGHBD_BFP(BLOCK_32X64,
vp9_high_sad32x64_bits12,
vp9_high_sad32x64_avg_bits12,
vp9_high_12_variance32x64,
vp9_high_12_sub_pixel_variance32x64,
vp9_high_12_sub_pixel_avg_variance32x64,
vp9_highbd_sad32x64_bits12,
vp9_highbd_sad32x64_avg_bits12,
vp9_highbd_12_variance32x64,
vp9_highbd_12_sub_pixel_variance32x64,
vp9_highbd_12_sub_pixel_avg_variance32x64,
NULL,
NULL,
vp9_high_sad32x64x4d_bits12)
vp9_highbd_sad32x64x4d_bits12)
HIGHBD_BFP(BLOCK_32X32,
vp9_high_sad32x32_bits12,
vp9_high_sad32x32_avg_bits12,
vp9_high_12_variance32x32,
vp9_high_12_sub_pixel_variance32x32,
vp9_high_12_sub_pixel_avg_variance32x32,
vp9_high_sad32x32x3_bits12,
vp9_high_sad32x32x8_bits12,
vp9_high_sad32x32x4d_bits12)
vp9_highbd_sad32x32_bits12,
vp9_highbd_sad32x32_avg_bits12,
vp9_highbd_12_variance32x32,
vp9_highbd_12_sub_pixel_variance32x32,
vp9_highbd_12_sub_pixel_avg_variance32x32,
vp9_highbd_sad32x32x3_bits12,
vp9_highbd_sad32x32x8_bits12,
vp9_highbd_sad32x32x4d_bits12)
HIGHBD_BFP(BLOCK_64X64,
vp9_high_sad64x64_bits12,
vp9_high_sad64x64_avg_bits12,
vp9_high_12_variance64x64,
vp9_high_12_sub_pixel_variance64x64,
vp9_high_12_sub_pixel_avg_variance64x64,
vp9_high_sad64x64x3_bits12,
vp9_high_sad64x64x8_bits12,
vp9_high_sad64x64x4d_bits12)
vp9_highbd_sad64x64_bits12,
vp9_highbd_sad64x64_avg_bits12,
vp9_highbd_12_variance64x64,
vp9_highbd_12_sub_pixel_variance64x64,
vp9_highbd_12_sub_pixel_avg_variance64x64,
vp9_highbd_sad64x64x3_bits12,
vp9_highbd_sad64x64x8_bits12,
vp9_highbd_sad64x64x4d_bits12)
HIGHBD_BFP(BLOCK_16X16,
vp9_high_sad16x16_bits12,
vp9_high_sad16x16_avg_bits12,
vp9_high_12_variance16x16,
vp9_high_12_sub_pixel_variance16x16,
vp9_high_12_sub_pixel_avg_variance16x16,
vp9_high_sad16x16x3_bits12,
vp9_high_sad16x16x8_bits12,
vp9_high_sad16x16x4d_bits12)
vp9_highbd_sad16x16_bits12,
vp9_highbd_sad16x16_avg_bits12,
vp9_highbd_12_variance16x16,
vp9_highbd_12_sub_pixel_variance16x16,
vp9_highbd_12_sub_pixel_avg_variance16x16,
vp9_highbd_sad16x16x3_bits12,
vp9_highbd_sad16x16x8_bits12,
vp9_highbd_sad16x16x4d_bits12)
HIGHBD_BFP(BLOCK_16X8,
vp9_high_sad16x8_bits12,
vp9_high_sad16x8_avg_bits12,
vp9_high_12_variance16x8,
vp9_high_12_sub_pixel_variance16x8,
vp9_high_12_sub_pixel_avg_variance16x8,
vp9_high_sad16x8x3_bits12,
vp9_high_sad16x8x8_bits12,
vp9_high_sad16x8x4d_bits12)
vp9_highbd_sad16x8_bits12,
vp9_highbd_sad16x8_avg_bits12,
vp9_highbd_12_variance16x8,
vp9_highbd_12_sub_pixel_variance16x8,
vp9_highbd_12_sub_pixel_avg_variance16x8,
vp9_highbd_sad16x8x3_bits12,
vp9_highbd_sad16x8x8_bits12,
vp9_highbd_sad16x8x4d_bits12)
HIGHBD_BFP(BLOCK_8X16,
vp9_high_sad8x16_bits12,
vp9_high_sad8x16_avg_bits12,
vp9_high_12_variance8x16,
vp9_high_12_sub_pixel_variance8x16,
vp9_high_12_sub_pixel_avg_variance8x16,
vp9_high_sad8x16x3_bits12,
vp9_high_sad8x16x8_bits12,
vp9_high_sad8x16x4d_bits12)
vp9_highbd_sad8x16_bits12,
vp9_highbd_sad8x16_avg_bits12,
vp9_highbd_12_variance8x16,
vp9_highbd_12_sub_pixel_variance8x16,
vp9_highbd_12_sub_pixel_avg_variance8x16,
vp9_highbd_sad8x16x3_bits12,
vp9_highbd_sad8x16x8_bits12,
vp9_highbd_sad8x16x4d_bits12)
HIGHBD_BFP(BLOCK_8X8,
vp9_high_sad8x8_bits12,
vp9_high_sad8x8_avg_bits12,
vp9_high_12_variance8x8,
vp9_high_12_sub_pixel_variance8x8,
vp9_high_12_sub_pixel_avg_variance8x8,
vp9_high_sad8x8x3_bits12,
vp9_high_sad8x8x8_bits12,
vp9_high_sad8x8x4d_bits12)
vp9_highbd_sad8x8_bits12,
vp9_highbd_sad8x8_avg_bits12,
vp9_highbd_12_variance8x8,
vp9_highbd_12_sub_pixel_variance8x8,
vp9_highbd_12_sub_pixel_avg_variance8x8,
vp9_highbd_sad8x8x3_bits12,
vp9_highbd_sad8x8x8_bits12,
vp9_highbd_sad8x8x4d_bits12)
HIGHBD_BFP(BLOCK_8X4,
vp9_high_sad8x4_bits12,
vp9_high_sad8x4_avg_bits12,
vp9_high_12_variance8x4,
vp9_high_12_sub_pixel_variance8x4,
vp9_high_12_sub_pixel_avg_variance8x4,
vp9_highbd_sad8x4_bits12,
vp9_highbd_sad8x4_avg_bits12,
vp9_highbd_12_variance8x4,
vp9_highbd_12_sub_pixel_variance8x4,
vp9_highbd_12_sub_pixel_avg_variance8x4,
NULL,
vp9_high_sad8x4x8_bits12,
vp9_high_sad8x4x4d_bits12)
vp9_highbd_sad8x4x8_bits12,
vp9_highbd_sad8x4x4d_bits12)
HIGHBD_BFP(BLOCK_4X8,
vp9_high_sad4x8_bits12,
vp9_high_sad4x8_avg_bits12,
vp9_high_12_variance4x8,
vp9_high_12_sub_pixel_variance4x8,
vp9_high_12_sub_pixel_avg_variance4x8,
vp9_highbd_sad4x8_bits12,
vp9_highbd_sad4x8_avg_bits12,
vp9_highbd_12_variance4x8,
vp9_highbd_12_sub_pixel_variance4x8,
vp9_highbd_12_sub_pixel_avg_variance4x8,
NULL,
vp9_high_sad4x8x8_bits12,
vp9_high_sad4x8x4d_bits12)
vp9_highbd_sad4x8x8_bits12,
vp9_highbd_sad4x8x4d_bits12)
HIGHBD_BFP(BLOCK_4X4,
vp9_high_sad4x4_bits12,
vp9_high_sad4x4_avg_bits12,
vp9_high_12_variance4x4,
vp9_high_12_sub_pixel_variance4x4,
vp9_high_12_sub_pixel_avg_variance4x4,
vp9_high_sad4x4x3_bits12,
vp9_high_sad4x4x8_bits12,
vp9_high_sad4x4x4d_bits12)
vp9_highbd_sad4x4_bits12,
vp9_highbd_sad4x4_avg_bits12,
vp9_highbd_12_variance4x4,
vp9_highbd_12_sub_pixel_variance4x4,
vp9_highbd_12_sub_pixel_avg_variance4x4,
vp9_highbd_sad4x4x3_bits12,
vp9_highbd_sad4x4x8_bits12,
vp9_highbd_sad4x4x4d_bits12)
break;
default:
@ -1878,21 +1878,21 @@ static int64_t highbd_get_sse(const uint8_t *a, int a_stride,
unsigned int sse = 0;
int sum = 0;
if (dw > 0) {
high_variance(&a[width - dw], a_stride, &b[width - dw], b_stride,
dw, height, &sse, &sum);
highbd_variance(&a[width - dw], a_stride, &b[width - dw], b_stride,
dw, height, &sse, &sum);
total_sse += sse;
}
if (dh > 0) {
high_variance(&a[(height - dh) * a_stride], a_stride,
&b[(height - dh) * b_stride], b_stride,
width - dw, dh, &sse, &sum);
highbd_variance(&a[(height - dh) * a_stride], a_stride,
&b[(height - dh) * b_stride], b_stride,
width - dw, dh, &sse, &sum);
total_sse += sse;
}
for (y = 0; y < height / 16; ++y) {
const uint8_t *pa = a;
const uint8_t *pb = b;
for (x = 0; x < width / 16; ++x) {
vp9_high_mse16x16(pa, a_stride, pb, b_stride, &sse);
vp9_highbd_mse16x16(pa, a_stride, pb, b_stride, &sse);
total_sse += sse;
pa += 16;
pb += 16;
@ -2243,10 +2243,10 @@ static void scale_and_extend_frame(const YV12_BUFFER_CONFIG *src,
#if CONFIG_VP9_HIGHBITDEPTH
if (src->flags & YV12_FLAG_HIGHBITDEPTH) {
vp9_high_convolve8(src_ptr, src_stride, dst_ptr, dst_stride,
kernel[x_q4 & 0xf], 16 * src_w / dst_w,
kernel[y_q4 & 0xf], 16 * src_h / dst_h,
16 / factor, 16 / factor, bd);
vp9_highbd_convolve8(src_ptr, src_stride, dst_ptr, dst_stride,
kernel[x_q4 & 0xf], 16 * src_w / dst_w,
kernel[y_q4 & 0xf], 16 * src_h / dst_h,
16 / factor, 16 / factor, bd);
} else {
vp9_convolve8(src_ptr, src_stride, dst_ptr, dst_stride,
kernel[x_q4 & 0xf], 16 * src_w / dst_w,
@ -3612,11 +3612,11 @@ int vp9_get_compressed_data(VP9_COMP *cpi, unsigned int *frame_flags,
const int lossless = is_lossless_requested(oxcf);
#if CONFIG_VP9_HIGHBITDEPTH
if (cpi->oxcf.use_highbitdepth)
cpi->mb.fwd_txm4x4 = lossless ? vp9_high_fwht4x4 : vp9_high_fdct4x4;
cpi->mb.fwd_txm4x4 = lossless ? vp9_highbd_fwht4x4 : vp9_highbd_fdct4x4;
else
cpi->mb.fwd_txm4x4 = lossless ? vp9_fwht4x4 : vp9_fdct4x4;
cpi->mb.high_itxm_add = lossless ? vp9_high_iwht4x4_add :
vp9_high_idct4x4_add;
cpi->mb.highbd_itxm_add = lossless ? vp9_highbd_iwht4x4_add :
vp9_highbd_idct4x4_add;
#else
cpi->mb.fwd_txm4x4 = lossless ? vp9_fwht4x4 : vp9_fdct4x4;
#endif // CONFIG_VP9_HIGHBITDEPTH
@ -3921,16 +3921,16 @@ int vp9_highbd_get_y_sse(const YV12_BUFFER_CONFIG *a,
assert((b->flags & YV12_FLAG_HIGHBITDEPTH) != 0);
switch (bit_depth) {
case VPX_BITS_8:
high_variance(a->y_buffer, a->y_stride, b->y_buffer, b->y_stride,
a->y_crop_width, a->y_crop_height, &sse, &sum);
highbd_variance(a->y_buffer, a->y_stride, b->y_buffer, b->y_stride,
a->y_crop_width, a->y_crop_height, &sse, &sum);
return (int) sse;
case VPX_BITS_10:
high_10_variance(a->y_buffer, a->y_stride, b->y_buffer, b->y_stride,
a->y_crop_width, a->y_crop_height, &sse, &sum);
highbd_10_variance(a->y_buffer, a->y_stride, b->y_buffer, b->y_stride,
a->y_crop_width, a->y_crop_height, &sse, &sum);
return (int) sse;
case VPX_BITS_12:
high_12_variance(a->y_buffer, a->y_stride, b->y_buffer, b->y_stride,
a->y_crop_width, a->y_crop_height, &sse, &sum);
highbd_12_variance(a->y_buffer, a->y_stride, b->y_buffer, b->y_stride,
a->y_crop_width, a->y_crop_height, &sse, &sum);
return (int) sse;
default:
assert(0 && "bit_depth should be VPX_BITS_8, VPX_BITS_10 or VPX_BITS_12");

24
vp9/encoder/vp9_firstpass.c
Просмотреть файл

@ -289,37 +289,37 @@ static vp9_variance_fn_t highbd_get_block_variance_fn(BLOCK_SIZE bsize,
default:
switch (bsize) {
case BLOCK_8X8:
return vp9_high_mse8x8;
return vp9_highbd_mse8x8;
case BLOCK_16X8:
return vp9_high_mse16x8;
return vp9_highbd_mse16x8;
case BLOCK_8X16:
return vp9_high_mse8x16;
return vp9_highbd_mse8x16;
default:
return vp9_high_mse16x16;
return vp9_highbd_mse16x16;
}
break;
case 10:
switch (bsize) {
case BLOCK_8X8:
return vp9_high_10_mse8x8;
return vp9_highbd_10_mse8x8;
case BLOCK_16X8:
return vp9_high_10_mse16x8;
return vp9_highbd_10_mse16x8;
case BLOCK_8X16:
return vp9_high_10_mse8x16;
return vp9_highbd_10_mse8x16;
default:
return vp9_high_10_mse16x16;
return vp9_highbd_10_mse16x16;
}
break;
case 12:
switch (bsize) {
case BLOCK_8X8:
return vp9_high_12_mse8x8;
return vp9_highbd_12_mse8x8;
case BLOCK_16X8:
return vp9_high_12_mse16x8;
return vp9_highbd_12_mse16x8;
case BLOCK_8X16:
return vp9_high_12_mse8x16;
return vp9_highbd_12_mse8x16;
default:
return vp9_high_12_mse16x16;
return vp9_highbd_12_mse16x16;
}
break;
}

4
vp9/encoder/vp9_mcomp.c
Просмотреть файл

@ -291,8 +291,8 @@ static INLINE const uint8_t *pre(const uint8_t *buf, int stride, int r, int c) {
if (second_pred != NULL) { \
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { \
DECLARE_ALIGNED_ARRAY(16, uint16_t, comp_pred16, 64 * 64); \
vp9_high_comp_avg_pred(comp_pred16, second_pred, w, h, y + offset, \
y_stride); \
vp9_highbd_comp_avg_pred(comp_pred16, second_pred, w, h, y + offset, \
y_stride); \
besterr = vfp->vf(CONVERT_TO_BYTEPTR(comp_pred16), w, z, src_stride, \
sse1); \
} else { \

4
vp9/encoder/vp9_pickmode.c
Просмотреть файл

@ -764,8 +764,8 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
pd->dst = orig_dst;
#if CONFIG_VP9_HIGHBITDEPTH
if (cm->use_highbitdepth) {
vp9_high_convolve_copy(best_pred->data, bw, pd->dst.buf, pd->dst.stride,
NULL, 0, NULL, 0, bw, bh, xd->bd);
vp9_highbd_convolve_copy(best_pred->data, bw, pd->dst.buf, pd->dst.stride,
NULL, 0, NULL, 0, bw, bh, xd->bd);
} else {
vp9_convolve_copy(best_pred->data, bw, pd->dst.buf, pd->dst.stride,
NULL, 0, NULL, 0, bw, bh);

104
vp9/encoder/vp9_quantize.c
Просмотреть файл

@ -41,10 +41,10 @@ void vp9_quantize_dc(const tran_low_t *coeff_ptr, int skip_block,
}
#if CONFIG_VP9_HIGHBITDEPTH
void vp9_high_quantize_dc(const tran_low_t *coeff_ptr, int skip_block,
const int16_t *round_ptr, const int16_t quant,
tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr,
const int16_t dequant_ptr, uint16_t *eob_ptr) {
void vp9_highbd_quantize_dc(const tran_low_t *coeff_ptr, int skip_block,
const int16_t *round_ptr, const int16_t quant,
tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr,
const int16_t dequant_ptr, uint16_t *eob_ptr) {
int eob = -1;
if (!skip_block) {
@ -88,10 +88,14 @@ void vp9_quantize_dc_32x32(const tran_low_t *coeff_ptr, int skip_block,
}
#if CONFIG_VP9_HIGHBITDEPTH
void vp9_high_quantize_dc_32x32(const tran_low_t *coeff_ptr, int skip_block,
const int16_t *round_ptr, const int16_t quant,
tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr,
const int16_t dequant_ptr, uint16_t *eob_ptr) {
void vp9_highbd_quantize_dc_32x32(const tran_low_t *coeff_ptr,
int skip_block,
const int16_t *round_ptr,
const int16_t quant,
tran_low_t *qcoeff_ptr,
tran_low_t *dqcoeff_ptr,
const int16_t dequant_ptr,
uint16_t *eob_ptr) {
int eob = -1;
if (!skip_block) {
@ -154,14 +158,20 @@ void vp9_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs,
}
#if CONFIG_VP9_HIGHBITDEPTH
void vp9_high_quantize_fp_c(const tran_low_t *coeff_ptr, intptr_t count,
int skip_block, const int16_t *zbin_ptr,
const int16_t *round_ptr, const int16_t *quant_ptr,
const int16_t *quant_shift_ptr,
tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr,
const int16_t *dequant_ptr,
int zbin_oq_value, uint16_t *eob_ptr,
const int16_t *scan, const int16_t *iscan) {
void vp9_highbd_quantize_fp_c(const tran_low_t *coeff_ptr,
intptr_t count,
int skip_block,
const int16_t *zbin_ptr,
const int16_t *round_ptr,
const int16_t *quant_ptr,
const int16_t *quant_shift_ptr,
tran_low_t *qcoeff_ptr,
tran_low_t *dqcoeff_ptr,
const int16_t *dequant_ptr,
int zbin_oq_value,
uint16_t *eob_ptr,
const int16_t *scan,
const int16_t *iscan) {
int i;
int eob = -1;
// TODO(jingning) Decide the need of these arguments after the
@ -242,17 +252,17 @@ void vp9_quantize_fp_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs,
}
#if CONFIG_VP9_HIGHBITDEPTH
void vp9_high_quantize_fp_32x32_c(const tran_low_t *coeff_ptr,
intptr_t n_coeffs, int skip_block,
const int16_t *zbin_ptr,
const int16_t *round_ptr,
const int16_t *quant_ptr,
const int16_t *quant_shift_ptr,
tran_low_t *qcoeff_ptr,
tran_low_t *dqcoeff_ptr,
const int16_t *dequant_ptr,
int zbin_oq_value, uint16_t *eob_ptr,
const int16_t *scan, const int16_t *iscan) {
void vp9_highbd_quantize_fp_32x32_c(const tran_low_t *coeff_ptr,
intptr_t n_coeffs, int skip_block,
const int16_t *zbin_ptr,
const int16_t *round_ptr,
const int16_t *quant_ptr,
const int16_t *quant_shift_ptr,
tran_low_t *qcoeff_ptr,
tran_low_t *dqcoeff_ptr,
const int16_t *dequant_ptr,
int zbin_oq_value, uint16_t *eob_ptr,
const int16_t *scan, const int16_t *iscan) {
int i, eob = -1;
(void)zbin_ptr;
(void)quant_shift_ptr;
@ -340,14 +350,14 @@ void vp9_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs,
}
#if CONFIG_VP9_HIGHBITDEPTH
void vp9_high_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs,
int skip_block, const int16_t *zbin_ptr,
const int16_t *round_ptr, const int16_t *quant_ptr,
const int16_t *quant_shift_ptr,
tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr,
const int16_t *dequant_ptr, int zbin_oq_value,
uint16_t *eob_ptr, const int16_t *scan,
const int16_t *iscan) {
void vp9_highbd_quantize_b_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs,
int skip_block, const int16_t *zbin_ptr,
const int16_t *round_ptr, const int16_t *quant_ptr,
const int16_t *quant_shift_ptr,
tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr,
const int16_t *dequant_ptr, int zbin_oq_value,
uint16_t *eob_ptr, const int16_t *scan,
const int16_t *iscan) {
int i, non_zero_count = (int)n_coeffs, eob = -1;
const int zbins[2] = { zbin_ptr[0] + zbin_oq_value,
zbin_ptr[1] + zbin_oq_value };
@ -452,17 +462,17 @@ void vp9_quantize_b_32x32_c(const tran_low_t *coeff_ptr, intptr_t n_coeffs,
}
#if CONFIG_VP9_HIGHBITDEPTH
void vp9_high_quantize_b_32x32_c(const tran_low_t *coeff_ptr,
intptr_t n_coeffs, int skip_block,
const int16_t *zbin_ptr,
const int16_t *round_ptr,
const int16_t *quant_ptr,
const int16_t *quant_shift_ptr,
tran_low_t *qcoeff_ptr,
tran_low_t *dqcoeff_ptr,
const int16_t *dequant_ptr,
int zbin_oq_value, uint16_t *eob_ptr,
const int16_t *scan, const int16_t *iscan) {
void vp9_highbd_quantize_b_32x32_c(const tran_low_t *coeff_ptr,
intptr_t n_coeffs, int skip_block,
const int16_t *zbin_ptr,
const int16_t *round_ptr,
const int16_t *quant_ptr,
const int16_t *quant_shift_ptr,
tran_low_t *qcoeff_ptr,
tran_low_t *dqcoeff_ptr,
const int16_t *dequant_ptr,
int zbin_oq_value, uint16_t *eob_ptr,
const int16_t *scan, const int16_t *iscan) {
const int zbins[2] = { ROUND_POWER_OF_TWO(zbin_ptr[0] + zbin_oq_value, 1),
ROUND_POWER_OF_TWO(zbin_ptr[1] + zbin_oq_value, 1) };
const int nzbins[2] = { zbins[0] * -1, zbins[1] * -1 };
@ -519,7 +529,7 @@ void vp9_regular_quantize_b_4x4(MACROBLOCK *x, int plane, int block,
#if CONFIG_VP9_HIGHBITDEPTH
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
vp9_high_quantize_b(BLOCK_OFFSET(p->coeff, block),
vp9_highbd_quantize_b(BLOCK_OFFSET(p->coeff, block),
16, x->skip_block,
p->zbin, p->round, p->quant, p->quant_shift,
BLOCK_OFFSET(p->qcoeff, block),

21
vp9/encoder/vp9_quantize.h
Просмотреть файл

@ -49,15 +49,18 @@ void vp9_regular_quantize_b_4x4(MACROBLOCK *x, int plane, int block,
const int16_t *scan, const int16_t *iscan);
#if CONFIG_VP9_HIGHBITDEPTH
void vp9_high_quantize_dc(const tran_low_t *coeff_ptr, int skip_block,
const int16_t *round_ptr, const int16_t quant_ptr,
tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr,
const int16_t dequant_ptr, uint16_t *eob_ptr);
void vp9_high_quantize_dc_32x32(const tran_low_t *coeff_ptr, int skip_block,
const int16_t *round_ptr,
const int16_t quant_ptr, tran_low_t *qcoeff_ptr,
tran_low_t *dqcoeff_ptr,
const int16_t dequant_ptr, uint16_t *eob_ptr);
void vp9_highbd_quantize_dc(const tran_low_t *coeff_ptr, int skip_block,
const int16_t *round_ptr, const int16_t quant_ptr,
tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr,
const int16_t dequant_ptr, uint16_t *eob_ptr);
void vp9_highbd_quantize_dc_32x32(const tran_low_t *coeff_ptr,
int skip_block,
const int16_t *round_ptr,
const int16_t quant_ptr,
tran_low_t *qcoeff_ptr,
tran_low_t *dqcoeff_ptr,
const int16_t dequant_ptr,
uint16_t *eob_ptr);
#endif
struct VP9_COMP;

76
vp9/encoder/vp9_rdopt.c
Просмотреть файл

@ -307,10 +307,10 @@ int64_t vp9_block_error_c(const tran_low_t *coeff, const tran_low_t *dqcoeff,
#if CONFIG_VP9_HIGHBITDEPTH
int64_t vp9_high_block_error_c(const tran_low_t *coeff,
const tran_low_t *dqcoeff,
intptr_t block_size,
int64_t *ssz, int bd) {
int64_t vp9_highbd_block_error_c(const tran_low_t *coeff,
const tran_low_t *dqcoeff,
intptr_t block_size,
int64_t *ssz, int bd) {
int i;
int64_t error = 0, sqcoeff = 0;
int shift = 2 * (bd - 8);
@ -433,8 +433,8 @@ static void dist_block(int plane, int block, TX_SIZE tx_size,
tran_low_t *const coeff = BLOCK_OFFSET(p->coeff, block);
tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
#if CONFIG_VP9_HIGHBITDEPTH
args->dist = vp9_high_block_error(coeff, dqcoeff, 16 << ss_txfrm_size,
&this_sse, bd) >> shift;
args->dist = vp9_highbd_block_error(coeff, dqcoeff, 16 << ss_txfrm_size,
&this_sse, bd) >> shift;
#else
args->dist = vp9_block_error(coeff, dqcoeff, 16 << ss_txfrm_size,
&this_sse) >> shift;
@ -816,36 +816,36 @@ static int64_t rd_pick_intra4x4block(VP9_COMP *cpi, MACROBLOCK *x, int ib,
x->skip_encode ? src : dst,
x->skip_encode ? src_stride : dst_stride,
dst, dst_stride, idx, idy, 0);
vp9_high_subtract_block(4, 4, src_diff, 8, src, src_stride,
dst, dst_stride, xd->bd);
vp9_highbd_subtract_block(4, 4, src_diff, 8, src, src_stride,
dst, dst_stride, xd->bd);
if (xd->lossless) {
const scan_order *so = &vp9_default_scan_orders[TX_4X4];
vp9_high_fwht4x4(src_diff, coeff, 8);
vp9_highbd_fwht4x4(src_diff, coeff, 8);
vp9_regular_quantize_b_4x4(x, 0, block, so->scan, so->iscan);
ratey += cost_coeffs(x, 0, block, tempa + idx, templ + idy, TX_4X4,
so->scan, so->neighbors,
cpi->sf.use_fast_coef_costing);
if (RDCOST(x->rdmult, x->rddiv, ratey, distortion) >= best_rd)
goto next_highbd;
vp9_high_iwht4x4_add(BLOCK_OFFSET(pd->dqcoeff, block),
dst, dst_stride,
p->eobs[block], xd->bd);
vp9_highbd_iwht4x4_add(BLOCK_OFFSET(pd->dqcoeff, block),
dst, dst_stride,
p->eobs[block], xd->bd);
} else {
int64_t unused;
const TX_TYPE tx_type = get_tx_type_4x4(PLANE_TYPE_Y, xd, block);
const scan_order *so = &vp9_scan_orders[TX_4X4][tx_type];
vp9_high_fht4x4(src_diff, coeff, 8, tx_type);
vp9_highbd_fht4x4(src_diff, coeff, 8, tx_type);
vp9_regular_quantize_b_4x4(x, 0, block, so->scan, so->iscan);
ratey += cost_coeffs(x, 0, block, tempa + idx, templ + idy, TX_4X4,
so->scan, so->neighbors,
cpi->sf.use_fast_coef_costing);
distortion += vp9_high_block_error(coeff,
BLOCK_OFFSET(pd->dqcoeff, block),
16, &unused, xd->bd) >> 2;
distortion += vp9_highbd_block_error(
coeff, BLOCK_OFFSET(pd->dqcoeff, block),
16, &unused, xd->bd) >> 2;
if (RDCOST(x->rdmult, x->rddiv, ratey, distortion) >= best_rd)
goto next_highbd;
vp9_high_iht4x4_add(tx_type, BLOCK_OFFSET(pd->dqcoeff, block),
dst, dst_stride, p->eobs[block], xd->bd);
vp9_highbd_iht4x4_add(tx_type, BLOCK_OFFSET(pd->dqcoeff, block),
dst, dst_stride, p->eobs[block], xd->bd);
}
}
}
@ -1340,13 +1340,13 @@ static int64_t encode_inter_mb_segment(VP9_COMP *cpi,
pd->pre[ref].stride)];
#if CONFIG_VP9_HIGHBITDEPTH
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
vp9_high_build_inter_predictor(pre, pd->pre[ref].stride,
dst, pd->dst.stride,
&mi->bmi[i].as_mv[ref].as_mv,
&xd->block_refs[ref]->sf, width, height, ref,
kernel, MV_PRECISION_Q3,
mi_col * MI_SIZE + 4 * (i % 2),
mi_row * MI_SIZE + 4 * (i / 2), xd->bd);
vp9_highbd_build_inter_predictor(pre, pd->pre[ref].stride,
dst, pd->dst.stride,
&mi->bmi[i].as_mv[ref].as_mv,
&xd->block_refs[ref]->sf, width, height,
ref, kernel, MV_PRECISION_Q3,
mi_col * MI_SIZE + 4 * (i % 2),
mi_row * MI_SIZE + 4 * (i / 2), xd->bd);
} else {
vp9_build_inter_predictor(pre, pd->pre[ref].stride,
dst, pd->dst.stride,
@ -1369,7 +1369,7 @@ static int64_t encode_inter_mb_segment(VP9_COMP *cpi,
#if CONFIG_VP9_HIGHBITDEPTH
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
vp9_high_subtract_block(
vp9_highbd_subtract_block(
height, width, raster_block_offset_int16(BLOCK_8X8, i, p->src_diff), 8,
src, p->src.stride, dst, pd->dst.stride, xd->bd);
} else {
@ -1396,9 +1396,9 @@ static int64_t encode_inter_mb_segment(VP9_COMP *cpi,
vp9_regular_quantize_b_4x4(x, 0, k, so->scan, so->iscan);
#if CONFIG_VP9_HIGHBITDEPTH
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
thisdistortion += vp9_high_block_error(coeff,
BLOCK_OFFSET(pd->dqcoeff, k),
16, &ssz, xd->bd);
thisdistortion += vp9_highbd_block_error(coeff,
BLOCK_OFFSET(pd->dqcoeff, k),
16, &ssz, xd->bd);
} else {
thisdistortion += vp9_block_error(coeff, BLOCK_OFFSET(pd->dqcoeff, k),
16, &ssz);
@ -2228,15 +2228,15 @@ static void joint_motion_search(VP9_COMP *cpi, MACROBLOCK *x,
// Get pred block from second frame.
#if CONFIG_VP9_HIGHBITDEPTH
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
vp9_high_build_inter_predictor(ref_yv12[!id].buf,
ref_yv12[!id].stride,
second_pred, pw,
&frame_mv[refs[!id]].as_mv,
&xd->block_refs[!id]->sf,
pw, ph, 0,
kernel, MV_PRECISION_Q3,
mi_col * MI_SIZE, mi_row * MI_SIZE,
xd->bd);
vp9_highbd_build_inter_predictor(ref_yv12[!id].buf,
ref_yv12[!id].stride,
second_pred, pw,
&frame_mv[refs[!id]].as_mv,
&xd->block_refs[!id]->sf,
pw, ph, 0,
kernel, MV_PRECISION_Q3,
mi_col * MI_SIZE, mi_row * MI_SIZE,
xd->bd);
} else {
vp9_build_inter_predictor(ref_yv12[!id].buf,
ref_yv12[!id].stride,

145
vp9/encoder/vp9_sad.c
Просмотреть файл

@ -32,7 +32,6 @@ static INLINE unsigned int sad(const uint8_t *a, int a_stride,
a += a_stride;
b += b_stride;
}
return sad;
}
@ -136,9 +135,9 @@ sadMxNxK(4, 4, 8)
sadMxNx4D(4, 4)
#if CONFIG_VP9_HIGHBITDEPTH
static INLINE unsigned int high_sad(const uint8_t *a8, int a_stride,
const uint8_t *b8, int b_stride,
int width, int height) {
static INLINE unsigned int highbd_sad(const uint8_t *a8, int a_stride,
const uint8_t *b8, int b_stride,
int width, int height) {
int y, x;
unsigned int sad = 0;
const uint16_t *a = CONVERT_TO_SHORTPTR(a8);
@ -153,9 +152,9 @@ static INLINE unsigned int high_sad(const uint8_t *a8, int a_stride,
return sad;
}
static INLINE unsigned int high_sadb(const uint8_t *a8, int a_stride,
const uint16_t *b, int b_stride,
int width, int height) {
static INLINE unsigned int highbd_sadb(const uint8_t *a8, int a_stride,
const uint16_t *b, int b_stride,
int width, int height) {
int y, x;
unsigned int sad = 0;
const uint16_t *a = CONVERT_TO_SHORTPTR(a8);
@ -169,103 +168,109 @@ static INLINE unsigned int high_sadb(const uint8_t *a8, int a_stride,
return sad;
}
#define high_sadMxN(m, n) \
unsigned int vp9_high_sad##m##x##n##_c(const uint8_t *src, int src_stride, \
const uint8_t *ref, int ref_stride) { \
return high_sad(src, src_stride, ref, ref_stride, m, n); \
#define highbd_sadMxN(m, n) \
unsigned int vp9_highbd_sad##m##x##n##_c(const uint8_t *src, int src_stride, \
const uint8_t *ref, int ref_stride) { \
return highbd_sad(src, src_stride, ref, ref_stride, m, n); \
} \
unsigned int vp9_high_sad##m##x##n##_avg_c(const uint8_t *src, int src_stride, \
const uint8_t *ref, int ref_stride, \
const uint8_t *second_pred) { \
unsigned int vp9_highbd_sad##m##x##n##_avg_c(const uint8_t *src, \
int src_stride, \
const uint8_t *ref, \
int ref_stride, \
const uint8_t *second_pred) { \
uint16_t comp_pred[m * n]; \
vp9_high_comp_avg_pred(comp_pred, second_pred, m, n, ref, ref_stride); \
return high_sadb(src, src_stride, comp_pred, m, m, n); \
vp9_highbd_comp_avg_pred(comp_pred, second_pred, m, n, ref, ref_stride); \
return highbd_sadb(src, src_stride, comp_pred, m, m, n); \
}
#define high_sadMxNxK(m, n, k) \
void vp9_high_sad##m##x##n##x##k##_c(const uint8_t *src, int src_stride, \
const uint8_t *ref, int ref_stride, \
unsigned int *sads) { \
#define highbd_sadMxNxK(m, n, k) \
void vp9_highbd_sad##m##x##n##x##k##_c(const uint8_t *src, int src_stride, \
const uint8_t *ref, int ref_stride, \
unsigned int *sads) { \
int i; \
for (i = 0; i < k; ++i) \
sads[i] = vp9_high_sad##m##x##n##_c(src, src_stride, &ref[i], ref_stride); \
for (i = 0; i < k; ++i) { \
sads[i] = vp9_highbd_sad##m##x##n##_c(src, src_stride, &ref[i], \
ref_stride); \
} \
}
#define high_sadMxNx4D(m, n) \
void vp9_high_sad##m##x##n##x4d_c(const uint8_t *src, int src_stride, \
const uint8_t *const refs[], \
int ref_stride, unsigned int *sads) { \
#define highbd_sadMxNx4D(m, n) \
void vp9_highbd_sad##m##x##n##x4d_c(const uint8_t *src, int src_stride, \
const uint8_t *const refs[], \
int ref_stride, unsigned int *sads) { \
int i; \
for (i = 0; i < 4; ++i) \
sads[i] = vp9_high_sad##m##x##n##_c(src, src_stride, refs[i], ref_stride); \
for (i = 0; i < 4; ++i) { \
sads[i] = vp9_highbd_sad##m##x##n##_c(src, src_stride, refs[i], \
ref_stride); \
} \
}
// 64x64
high_sadMxN(64, 64)
high_sadMxNxK(64, 64, 3)
high_sadMxNxK(64, 64, 8)
high_sadMxNx4D(64, 64)
highbd_sadMxN(64, 64)
highbd_sadMxNxK(64, 64, 3)
highbd_sadMxNxK(64, 64, 8)
highbd_sadMxNx4D(64, 64)
// 64x32
high_sadMxN(64, 32)
high_sadMxNx4D(64, 32)
highbd_sadMxN(64, 32)
highbd_sadMxNx4D(64, 32)
// 32x64
high_sadMxN(32, 64)
high_sadMxNx4D(32, 64)
highbd_sadMxN(32, 64)
highbd_sadMxNx4D(32, 64)
// 32x32
high_sadMxN(32, 32)
high_sadMxNxK(32, 32, 3)
high_sadMxNxK(32, 32, 8)
high_sadMxNx4D(32, 32)
highbd_sadMxN(32, 32)
highbd_sadMxNxK(32, 32, 3)
highbd_sadMxNxK(32, 32, 8)
highbd_sadMxNx4D(32, 32)
// 32x16
high_sadMxN(32, 16)
high_sadMxNx4D(32, 16)
highbd_sadMxN(32, 16)
highbd_sadMxNx4D(32, 16)
// 16x32
high_sadMxN(16, 32)
high_sadMxNx4D(16, 32)
highbd_sadMxN(16, 32)
highbd_sadMxNx4D(16, 32)
// 16x16
high_sadMxN(16, 16)
high_sadMxNxK(16, 16, 3)
high_sadMxNxK(16, 16, 8)
high_sadMxNx4D(16, 16)
highbd_sadMxN(16, 16)
highbd_sadMxNxK(16, 16, 3)
highbd_sadMxNxK(16, 16, 8)
highbd_sadMxNx4D(16, 16)
// 16x8
high_sadMxN(16, 8)
high_sadMxNxK(16, 8, 3)
high_sadMxNxK(16, 8, 8)
high_sadMxNx4D(16, 8)
highbd_sadMxN(16, 8)
highbd_sadMxNxK(16, 8, 3)
highbd_sadMxNxK(16, 8, 8)
highbd_sadMxNx4D(16, 8)
// 8x16
high_sadMxN(8, 16)
high_sadMxNxK(8, 16, 3)
high_sadMxNxK(8, 16, 8)
high_sadMxNx4D(8, 16)
highbd_sadMxN(8, 16)
highbd_sadMxNxK(8, 16, 3)
highbd_sadMxNxK(8, 16, 8)
highbd_sadMxNx4D(8, 16)
// 8x8
high_sadMxN(8, 8)
high_sadMxNxK(8, 8, 3)
high_sadMxNxK(8, 8, 8)
high_sadMxNx4D(8, 8)
highbd_sadMxN(8, 8)
highbd_sadMxNxK(8, 8, 3)
highbd_sadMxNxK(8, 8, 8)
highbd_sadMxNx4D(8, 8)
// 8x4
high_sadMxN(8, 4)
high_sadMxNxK(8, 4, 8)
high_sadMxNx4D(8, 4)
highbd_sadMxN(8, 4)
highbd_sadMxNxK(8, 4, 8)
highbd_sadMxNx4D(8, 4)
// 4x8
high_sadMxN(4, 8)
high_sadMxNxK(4, 8, 8)
high_sadMxNx4D(4, 8)
highbd_sadMxN(4, 8)
highbd_sadMxNxK(4, 8, 8)
highbd_sadMxNx4D(4, 8)
// 4x4
high_sadMxN(4, 4)
high_sadMxNxK(4, 4, 3)
high_sadMxNxK(4, 4, 8)
high_sadMxNx4D(4, 4)
highbd_sadMxN(4, 4)
highbd_sadMxNxK(4, 4, 3)
highbd_sadMxNxK(4, 4, 8)
highbd_sadMxNx4D(4, 4)
#endif // CONFIG_VP9_HIGHBITDEPTH

42
vp9/encoder/vp9_temporal_filter.c
Просмотреть файл

@ -58,29 +58,29 @@ static void temporal_filter_predictors_mb_c(MACROBLOCKD *xd,
#if CONFIG_VP9_HIGHBITDEPTH
if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
vp9_high_build_inter_predictor(y_mb_ptr, stride,
&pred[0], 16,
&mv,
scale,
16, 16,
which_mv,
kernel, MV_PRECISION_Q3, x, y, xd->bd);
vp9_highbd_build_inter_predictor(y_mb_ptr, stride,
&pred[0], 16,
&mv,
scale,
16, 16,
which_mv,
kernel, MV_PRECISION_Q3, x, y, xd->bd);
vp9_high_build_inter_predictor(u_mb_ptr, uv_stride,
&pred[256], uv_block_width,
&mv,
scale,
uv_block_width, uv_block_height,
which_mv,
kernel, mv_precision_uv, x, y, xd->bd);
vp9_highbd_build_inter_predictor(u_mb_ptr, uv_stride,
&pred[256], uv_block_width,
&mv,
scale,
uv_block_width, uv_block_height,
which_mv,
kernel, mv_precision_uv, x, y, xd->bd);
vp9_high_build_inter_predictor(v_mb_ptr, uv_stride,
&pred[512], uv_block_width,
&mv,
scale,
uv_block_width, uv_block_height,
which_mv,
kernel, mv_precision_uv, x, y, xd->bd);
vp9_highbd_build_inter_predictor(v_mb_ptr, uv_stride,
&pred[512], uv_block_width,
&mv,
scale,
uv_block_width, uv_block_height,
which_mv,
kernel, mv_precision_uv, x, y, xd->bd);
return;
}
#endif // CONFIG_VP9_HIGHBITDEPTH

506
vp9/encoder/vp9_variance.c
Просмотреть файл

@ -269,10 +269,10 @@ void vp9_comp_avg_pred(uint8_t *comp_pred, const uint8_t *pred, int width,
}
#if CONFIG_VP9_HIGHBITDEPTH
void high_variance64(const uint8_t *a8, int a_stride,
const uint8_t *b8, int b_stride,
int w, int h, uint64_t *sse,
uint64_t *sum) {
void highbd_variance64(const uint8_t *a8, int a_stride,
const uint8_t *b8, int b_stride,
int w, int h, uint64_t *sse,
uint64_t *sum) {
int i, j;
uint16_t *a = CONVERT_TO_SHORTPTR(a8);
@ -291,40 +291,40 @@ void high_variance64(const uint8_t *a8, int a_stride,
}
}
void high_variance(const uint8_t *a8, int a_stride,
const uint8_t *b8, int b_stride,
int w, int h, unsigned int *sse,
int *sum) {
void highbd_variance(const uint8_t *a8, int a_stride,
const uint8_t *b8, int b_stride,
int w, int h, unsigned int *sse,
int *sum) {
uint64_t sse_long = 0;
uint64_t sum_long = 0;
high_variance64(a8, a_stride, b8, b_stride, w, h, &sse_long, &sum_long);
highbd_variance64(a8, a_stride, b8, b_stride, w, h, &sse_long, &sum_long);
*sse = sse_long;
*sum = sum_long;
}
void high_10_variance(const uint8_t *a8, int a_stride,
const uint8_t *b8, int b_stride,
int w, int h, unsigned int *sse,
int *sum) {
void highbd_10_variance(const uint8_t *a8, int a_stride,
const uint8_t *b8, int b_stride,
int w, int h, unsigned int *sse,
int *sum) {
uint64_t sse_long = 0;
uint64_t sum_long = 0;
high_variance64(a8, a_stride, b8, b_stride, w, h, &sse_long, &sum_long);
highbd_variance64(a8, a_stride, b8, b_stride, w, h, &sse_long, &sum_long);
*sum = ROUND_POWER_OF_TWO(sum_long, 2);
*sse = ROUND_POWER_OF_TWO(sse_long, 4);
}
void high_12_variance(const uint8_t *a8, int a_stride,
const uint8_t *b8, int b_stride,
int w, int h, unsigned int *sse,
int *sum) {
void highbd_12_variance(const uint8_t *a8, int a_stride,
const uint8_t *b8, int b_stride,
int w, int h, unsigned int *sse,
int *sum) {
uint64_t sse_long = 0;
uint64_t sum_long = 0;
high_variance64(a8, a_stride, b8, b_stride, w, h, &sse_long, &sum_long);
highbd_variance64(a8, a_stride, b8, b_stride, w, h, &sse_long, &sum_long);
*sum = ROUND_POWER_OF_TWO(sum_long, 4);
*sse = ROUND_POWER_OF_TWO(sse_long, 8);
}
static void high_var_filter_block2d_bil_first_pass(
static void highbd_var_filter_block2d_bil_first_pass(
const uint8_t *src_ptr8,
uint16_t *output_ptr,
unsigned int src_pixels_per_line,
@ -350,7 +350,7 @@ static void high_var_filter_block2d_bil_first_pass(
}
}
static void high_var_filter_block2d_bil_second_pass(
static void highbd_var_filter_block2d_bil_second_pass(
const uint16_t *src_ptr,
uint16_t *output_ptr,
unsigned int src_pixels_per_line,
@ -374,257 +374,267 @@ static void high_var_filter_block2d_bil_second_pass(
}
}
#define HIGH_VAR(W, H) \
unsigned int vp9_high_variance##W##x##H##_c(const uint8_t *a, int a_stride, \
const uint8_t *b, int b_stride, \
#define HIGHBD_VAR(W, H) \
unsigned int vp9_highbd_variance##W##x##H##_c(const uint8_t *a, int a_stride, \
const uint8_t *b, int b_stride, \
unsigned int *sse) { \
int sum; \
highbd_variance(a, a_stride, b, b_stride, W, H, sse, &sum); \
return *sse - (((int64_t)sum * sum) / (W * H)); \
} \
\
unsigned int vp9_highbd_10_variance##W##x##H##_c(const uint8_t *a, \
int a_stride, \
const uint8_t *b, \
int b_stride, \
unsigned int *sse) { \
int sum; \
highbd_10_variance(a, a_stride, b, b_stride, W, H, sse, &sum); \
return *sse - (((int64_t)sum * sum) / (W * H)); \
} \
\
unsigned int vp9_highbd_12_variance##W##x##H##_c(const uint8_t *a, \
int a_stride, \
const uint8_t *b, \
int b_stride, \
unsigned int *sse) { \
int sum; \
highbd_12_variance(a, a_stride, b, b_stride, W, H, sse, &sum); \
return *sse - (((int64_t)sum * sum) / (W * H)); \
}
#define HIGHBD_SUBPIX_VAR(W, H) \
unsigned int vp9_highbd_sub_pixel_variance##W##x##H##_c( \
const uint8_t *src, int src_stride, \
int xoffset, int yoffset, \
const uint8_t *dst, int dst_stride, \
unsigned int *sse) { \
uint16_t fdata3[(H + 1) * W]; \
uint16_t temp2[H * W]; \
\
highbd_var_filter_block2d_bil_first_pass(src, fdata3, src_stride, 1, H + 1, \
W, BILINEAR_FILTERS_2TAP(xoffset)); \
highbd_var_filter_block2d_bil_second_pass(fdata3, temp2, W, W, H, W, \
BILINEAR_FILTERS_2TAP(yoffset)); \
\
return vp9_highbd_variance##W##x##H##_c(CONVERT_TO_BYTEPTR(temp2), W, dst, \
dst_stride, sse); \
} \
\
unsigned int vp9_highbd_10_sub_pixel_variance##W##x##H##_c( \
const uint8_t *src, int src_stride, \
int xoffset, int yoffset, \
const uint8_t *dst, int dst_stride, \
unsigned int *sse) { \
uint16_t fdata3[(H + 1) * W]; \
uint16_t temp2[H * W]; \
\
highbd_var_filter_block2d_bil_first_pass(src, fdata3, src_stride, 1, H + 1, \
W, BILINEAR_FILTERS_2TAP(xoffset)); \
highbd_var_filter_block2d_bil_second_pass(fdata3, temp2, W, W, H, W, \
BILINEAR_FILTERS_2TAP(yoffset)); \
\
return vp9_highbd_10_variance##W##x##H##_c(CONVERT_TO_BYTEPTR(temp2), \
W, dst, dst_stride, sse); \
} \
\
unsigned int vp9_highbd_12_sub_pixel_variance##W##x##H##_c( \
const uint8_t *src, int src_stride, \
int xoffset, int yoffset, \
const uint8_t *dst, int dst_stride, \
unsigned int *sse) { \
uint16_t fdata3[(H + 1) * W]; \
uint16_t temp2[H * W]; \
\
highbd_var_filter_block2d_bil_first_pass(src, fdata3, src_stride, 1, H + 1, \
W, BILINEAR_FILTERS_2TAP(xoffset)); \
highbd_var_filter_block2d_bil_second_pass(fdata3, temp2, W, W, H, W, \
BILINEAR_FILTERS_2TAP(yoffset)); \
\
return vp9_highbd_12_variance##W##x##H##_c(CONVERT_TO_BYTEPTR(temp2), \
W, dst, dst_stride, sse); \
}
#define HIGHBD_SUBPIX_AVG_VAR(W, H) \
unsigned int vp9_highbd_sub_pixel_avg_variance##W##x##H##_c( \
const uint8_t *src, int src_stride, \
int xoffset, int yoffset, \
const uint8_t *dst, int dst_stride, \
unsigned int *sse, \
const uint8_t *second_pred) { \
uint16_t fdata3[(H + 1) * W]; \
uint16_t temp2[H * W]; \
DECLARE_ALIGNED_ARRAY(16, uint16_t, temp3, H * W); \
\
highbd_var_filter_block2d_bil_first_pass(src, fdata3, src_stride, 1, H + 1, \
W, BILINEAR_FILTERS_2TAP(xoffset)); \
highbd_var_filter_block2d_bil_second_pass(fdata3, temp2, W, W, H, W, \
BILINEAR_FILTERS_2TAP(yoffset)); \
\
vp9_highbd_comp_avg_pred(temp3, second_pred, W, H, \
CONVERT_TO_BYTEPTR(temp2), W); \
\
return vp9_highbd_variance##W##x##H##_c(CONVERT_TO_BYTEPTR(temp3), W, dst, \
dst_stride, sse); \
} \
\
unsigned int vp9_highbd_10_sub_pixel_avg_variance##W##x##H##_c( \
const uint8_t *src, int src_stride, \
int xoffset, int yoffset, \
const uint8_t *dst, int dst_stride, \
unsigned int *sse, \
const uint8_t *second_pred) { \
uint16_t fdata3[(H + 1) * W]; \
uint16_t temp2[H * W]; \
DECLARE_ALIGNED_ARRAY(16, uint16_t, temp3, H * W); \
\
highbd_var_filter_block2d_bil_first_pass(src, fdata3, src_stride, 1, H + 1, \
W, BILINEAR_FILTERS_2TAP(xoffset)); \
highbd_var_filter_block2d_bil_second_pass(fdata3, temp2, W, W, H, W, \
BILINEAR_FILTERS_2TAP(yoffset)); \
\
vp9_highbd_comp_avg_pred(temp3, second_pred, W, H, \
CONVERT_TO_BYTEPTR(temp2), W); \
\
return vp9_highbd_10_variance##W##x##H##_c(CONVERT_TO_BYTEPTR(temp3), \
W, dst, dst_stride, sse); \
} \
\
unsigned int vp9_highbd_12_sub_pixel_avg_variance##W##x##H##_c( \
const uint8_t *src, int src_stride, \
int xoffset, int yoffset, \
const uint8_t *dst, int dst_stride, \
unsigned int *sse, \
const uint8_t *second_pred) { \
uint16_t fdata3[(H + 1) * W]; \
uint16_t temp2[H * W]; \
DECLARE_ALIGNED_ARRAY(16, uint16_t, temp3, H * W); \
\
highbd_var_filter_block2d_bil_first_pass(src, fdata3, src_stride, 1, H + 1, \
W, BILINEAR_FILTERS_2TAP(xoffset)); \
highbd_var_filter_block2d_bil_second_pass(fdata3, temp2, W, W, H, W, \
BILINEAR_FILTERS_2TAP(yoffset)); \
\
vp9_highbd_comp_avg_pred(temp3, second_pred, W, H, \
CONVERT_TO_BYTEPTR(temp2), W); \
\
return vp9_highbd_12_variance##W##x##H##_c(CONVERT_TO_BYTEPTR(temp3), \
W, dst, dst_stride, sse); \
}
#define HIGHBD_GET_VAR(S) \
void vp9_highbd_get##S##x##S##var_c(const uint8_t *src, int src_stride, \
const uint8_t *ref, int ref_stride, \
unsigned int *sse, int *sum) { \
highbd_variance(src, src_stride, ref, ref_stride, S, S, sse, sum); \
} \
\
void vp9_highbd_10_get##S##x##S##var_c(const uint8_t *src, int src_stride, \
const uint8_t *ref, int ref_stride, \
unsigned int *sse, int *sum) { \
highbd_10_variance(src, src_stride, ref, ref_stride, S, S, sse, sum); \
} \
\
void vp9_highbd_12_get##S##x##S##var_c(const uint8_t *src, int src_stride, \
const uint8_t *ref, int ref_stride, \
unsigned int *sse, int *sum) { \
highbd_12_variance(src, src_stride, ref, ref_stride, S, S, sse, sum); \
}
#define HIGHBD_MSE(W, H) \
unsigned int vp9_highbd_mse##W##x##H##_c(const uint8_t *src, \
int src_stride, \
const uint8_t *ref, \
int ref_stride, \
unsigned int *sse) { \
int sum; \
highbd_variance(src, src_stride, ref, ref_stride, W, H, sse, &sum); \
return *sse; \
} \
\
unsigned int vp9_highbd_10_mse##W##x##H##_c(const uint8_t *src, \
int src_stride, \
const uint8_t *ref, \
int ref_stride, \
unsigned int *sse) { \
int sum; \
high_variance(a, a_stride, b, b_stride, W, H, sse, &sum); \
return *sse - (((int64_t)sum * sum) / (W * H)); \
} \
\
unsigned int vp9_high_10_variance##W##x##H##_c(const uint8_t *a, int a_stride, \
const uint8_t *b, int b_stride, \
unsigned int *sse) { \
int sum; \
high_10_variance(a, a_stride, b, b_stride, W, H, sse, &sum); \
return *sse - (((int64_t)sum * sum) / (W * H)); \
} \
\
unsigned int vp9_high_12_variance##W##x##H##_c(const uint8_t *a, int a_stride, \
const uint8_t *b, int b_stride, \
unsigned int *sse) { \
int sum; \
high_12_variance(a, a_stride, b, b_stride, W, H, sse, &sum); \
return *sse - (((int64_t)sum * sum) / (W * H)); \
}
#define HIGH_SUBPIX_VAR(W, H) \
unsigned int vp9_high_sub_pixel_variance##W##x##H##_c( \
const uint8_t *src, int src_stride, \
int xoffset, int yoffset, \
const uint8_t *dst, int dst_stride, \
unsigned int *sse) { \
uint16_t fdata3[(H + 1) * W]; \
uint16_t temp2[H * W]; \
\
high_var_filter_block2d_bil_first_pass(src, fdata3, src_stride, 1, H + 1, \
W, BILINEAR_FILTERS_2TAP(xoffset)); \
high_var_filter_block2d_bil_second_pass(fdata3, temp2, W, W, H, W, \
BILINEAR_FILTERS_2TAP(yoffset)); \
\
return vp9_high_variance##W##x##H##_c(CONVERT_TO_BYTEPTR(temp2), W, dst, \
dst_stride, sse); \
} \
\
unsigned int vp9_high_10_sub_pixel_variance##W##x##H##_c( \
const uint8_t *src, int src_stride, \
int xoffset, int yoffset, \
const uint8_t *dst, int dst_stride, \
unsigned int *sse) { \
uint16_t fdata3[(H + 1) * W]; \
uint16_t temp2[H * W]; \
\
high_var_filter_block2d_bil_first_pass(src, fdata3, src_stride, 1, H + 1, \
W, BILINEAR_FILTERS_2TAP(xoffset)); \
high_var_filter_block2d_bil_second_pass(fdata3, temp2, W, W, H, W, \
BILINEAR_FILTERS_2TAP(yoffset)); \
\
return vp9_high_10_variance##W##x##H##_c(CONVERT_TO_BYTEPTR(temp2), W, dst, \
dst_stride, sse); \
} \
\
unsigned int vp9_high_12_sub_pixel_variance##W##x##H##_c( \
const uint8_t *src, int src_stride, \
int xoffset, int yoffset, \
const uint8_t *dst, int dst_stride, \
unsigned int *sse) { \
uint16_t fdata3[(H + 1) * W]; \
uint16_t temp2[H * W]; \
\
high_var_filter_block2d_bil_first_pass(src, fdata3, src_stride, 1, H + 1, \
W, BILINEAR_FILTERS_2TAP(xoffset)); \
high_var_filter_block2d_bil_second_pass(fdata3, temp2, W, W, H, W, \
BILINEAR_FILTERS_2TAP(yoffset)); \
\
return vp9_high_12_variance##W##x##H##_c(CONVERT_TO_BYTEPTR(temp2), W, dst, \
dst_stride, sse); \
}
#define HIGH_SUBPIX_AVG_VAR(W, H) \
unsigned int vp9_high_sub_pixel_avg_variance##W##x##H##_c( \
const uint8_t *src, int src_stride, \
int xoffset, int yoffset, \
const uint8_t *dst, int dst_stride, \
unsigned int *sse, \
const uint8_t *second_pred) { \
uint16_t fdata3[(H + 1) * W]; \
uint16_t temp2[H * W]; \
DECLARE_ALIGNED_ARRAY(16, uint16_t, temp3, H * W); \
\
high_var_filter_block2d_bil_first_pass(src, fdata3, src_stride, 1, H + 1, \
W, BILINEAR_FILTERS_2TAP(xoffset)); \
high_var_filter_block2d_bil_second_pass(fdata3, temp2, W, W, H, W, \
BILINEAR_FILTERS_2TAP(yoffset)); \
\
vp9_high_comp_avg_pred(temp3, second_pred, W, H, CONVERT_TO_BYTEPTR(temp2), \
W); \
\
return vp9_high_variance##W##x##H##_c(CONVERT_TO_BYTEPTR(temp3), W, dst, \
dst_stride, sse); \
} \
\
unsigned int vp9_high_10_sub_pixel_avg_variance##W##x##H##_c( \
const uint8_t *src, int src_stride, \
int xoffset, int yoffset, \
const uint8_t *dst, int dst_stride, \
unsigned int *sse, \
const uint8_t *second_pred) { \
uint16_t fdata3[(H + 1) * W]; \
uint16_t temp2[H * W]; \
DECLARE_ALIGNED_ARRAY(16, uint16_t, temp3, H * W); \
\
high_var_filter_block2d_bil_first_pass(src, fdata3, src_stride, 1, H + 1, \
W, BILINEAR_FILTERS_2TAP(xoffset)); \
high_var_filter_block2d_bil_second_pass(fdata3, temp2, W, W, H, W, \
BILINEAR_FILTERS_2TAP(yoffset)); \
\
vp9_high_comp_avg_pred(temp3, second_pred, W, H, CONVERT_TO_BYTEPTR(temp2), \
W); \
\
return vp9_high_10_variance##W##x##H##_c(CONVERT_TO_BYTEPTR(temp3), W, dst, \
dst_stride, sse); \
} \
\
unsigned int vp9_high_12_sub_pixel_avg_variance##W##x##H##_c( \
const uint8_t *src, int src_stride, \
int xoffset, int yoffset, \
const uint8_t *dst, int dst_stride, \
unsigned int *sse, \
const uint8_t *second_pred) { \
uint16_t fdata3[(H + 1) * W]; \
uint16_t temp2[H * W]; \
DECLARE_ALIGNED_ARRAY(16, uint16_t, temp3, H * W); \
\
high_var_filter_block2d_bil_first_pass(src, fdata3, src_stride, 1, H + 1, \
W, BILINEAR_FILTERS_2TAP(xoffset)); \
high_var_filter_block2d_bil_second_pass(fdata3, temp2, W, W, H, W, \
BILINEAR_FILTERS_2TAP(yoffset)); \
\
vp9_high_comp_avg_pred(temp3, second_pred, W, H, CONVERT_TO_BYTEPTR(temp2), \
W); \
\
return vp9_high_12_variance##W##x##H##_c(CONVERT_TO_BYTEPTR(temp3), W, dst, \
dst_stride, sse); \
}
#define HIGH_GET_VAR(S) \
void vp9_high_get##S##x##S##var_c(const uint8_t *src, int src_stride, \
const uint8_t *ref, int ref_stride, \
unsigned int *sse, int *sum) { \
high_variance(src, src_stride, ref, ref_stride, S, S, sse, sum); \
} \
\
void vp9_high_10_get##S##x##S##var_c(const uint8_t *src, int src_stride, \
const uint8_t *ref, int ref_stride, \
unsigned int *sse, int *sum) { \
high_10_variance(src, src_stride, ref, ref_stride, S, S, sse, sum); \
} \
\
void vp9_high_12_get##S##x##S##var_c(const uint8_t *src, int src_stride, \
const uint8_t *ref, int ref_stride, \
unsigned int *sse, int *sum) { \
high_12_variance(src, src_stride, ref, ref_stride, S, S, sse, sum); \
}
#define HIGH_MSE(W, H) \
unsigned int vp9_high_mse##W##x##H##_c(const uint8_t *src, int src_stride, \
const uint8_t *ref, int ref_stride, \
unsigned int *sse) { \
int sum; \
high_variance(src, src_stride, ref, ref_stride, W, H, sse, &sum); \
highbd_10_variance(src, src_stride, ref, ref_stride, W, H, sse, &sum); \
return *sse; \
} \
\
unsigned int vp9_high_10_mse##W##x##H##_c(const uint8_t *src, int src_stride, \
const uint8_t *ref, int ref_stride, \
unsigned int *sse) { \
unsigned int vp9_highbd_12_mse##W##x##H##_c(const uint8_t *src, \
int src_stride, \
const uint8_t *ref, \
int ref_stride, \
unsigned int *sse) { \
int sum; \
high_10_variance(src, src_stride, ref, ref_stride, W, H, sse, &sum); \
return *sse; \
} \
\
unsigned int vp9_high_12_mse##W##x##H##_c(const uint8_t *src, int src_stride, \
const uint8_t *ref, int ref_stride, \
unsigned int *sse) { \
int sum; \
high_12_variance(src, src_stride, ref, ref_stride, W, H, sse, &sum); \
highbd_12_variance(src, src_stride, ref, ref_stride, W, H, sse, &sum); \
return *sse; \
}
HIGH_GET_VAR(8)
HIGH_GET_VAR(16)
HIGHBD_GET_VAR(8)
HIGHBD_GET_VAR(16)
HIGH_MSE(16, 16)
HIGH_MSE(16, 8)
HIGH_MSE(8, 16)
HIGH_MSE(8, 8)
HIGHBD_MSE(16, 16)
HIGHBD_MSE(16, 8)
HIGHBD_MSE(8, 16)
HIGHBD_MSE(8, 8)
HIGH_VAR(4, 4)
HIGH_SUBPIX_VAR(4, 4)
HIGH_SUBPIX_AVG_VAR(4, 4)
HIGHBD_VAR(4, 4)
HIGHBD_SUBPIX_VAR(4, 4)
HIGHBD_SUBPIX_AVG_VAR(4, 4)
HIGH_VAR(4, 8)
HIGH_SUBPIX_VAR(4, 8)
HIGH_SUBPIX_AVG_VAR(4, 8)
HIGHBD_VAR(4, 8)
HIGHBD_SUBPIX_VAR(4, 8)
HIGHBD_SUBPIX_AVG_VAR(4, 8)
HIGH_VAR(8, 4)
HIGH_SUBPIX_VAR(8, 4)
HIGH_SUBPIX_AVG_VAR(8, 4)
HIGHBD_VAR(8, 4)
HIGHBD_SUBPIX_VAR(8, 4)
HIGHBD_SUBPIX_AVG_VAR(8, 4)
HIGH_VAR(8, 8)
HIGH_SUBPIX_VAR(8, 8)
HIGH_SUBPIX_AVG_VAR(8, 8)
HIGHBD_VAR(8, 8)
HIGHBD_SUBPIX_VAR(8, 8)
HIGHBD_SUBPIX_AVG_VAR(8, 8)
HIGH_VAR(8, 16)
HIGH_SUBPIX_VAR(8, 16)
HIGH_SUBPIX_AVG_VAR(8, 16)
HIGHBD_VAR(8, 16)
HIGHBD_SUBPIX_VAR(8, 16)
HIGHBD_SUBPIX_AVG_VAR(8, 16)
HIGH_VAR(16, 8)
HIGH_SUBPIX_VAR(16, 8)
HIGH_SUBPIX_AVG_VAR(16, 8)
HIGHBD_VAR(16, 8)
HIGHBD_SUBPIX_VAR(16, 8)
HIGHBD_SUBPIX_AVG_VAR(16, 8)
HIGH_VAR(16, 16)
HIGH_SUBPIX_VAR(16, 16)
HIGH_SUBPIX_AVG_VAR(16, 16)
HIGHBD_VAR(16, 16)
HIGHBD_SUBPIX_VAR(16, 16)
HIGHBD_SUBPIX_AVG_VAR(16, 16)
HIGH_VAR(16, 32)
HIGH_SUBPIX_VAR(16, 32)
HIGH_SUBPIX_AVG_VAR(16, 32)
HIGHBD_VAR(16, 32)
HIGHBD_SUBPIX_VAR(16, 32)
HIGHBD_SUBPIX_AVG_VAR(16, 32)
HIGH_VAR(32, 16)
HIGH_SUBPIX_VAR(32, 16)
HIGH_SUBPIX_AVG_VAR(32, 16)
HIGHBD_VAR(32, 16)
HIGHBD_SUBPIX_VAR(32, 16)
HIGHBD_SUBPIX_AVG_VAR(32, 16)
HIGH_VAR(32, 32)
HIGH_SUBPIX_VAR(32, 32)
HIGH_SUBPIX_AVG_VAR(32, 32)
HIGHBD_VAR(32, 32)
HIGHBD_SUBPIX_VAR(32, 32)
HIGHBD_SUBPIX_AVG_VAR(32, 32)
HIGH_VAR(32, 64)
HIGH_SUBPIX_VAR(32, 64)
HIGH_SUBPIX_AVG_VAR(32, 64)
HIGHBD_VAR(32, 64)
HIGHBD_SUBPIX_VAR(32, 64)
HIGHBD_SUBPIX_AVG_VAR(32, 64)
HIGH_VAR(64, 32)
HIGH_SUBPIX_VAR(64, 32)
HIGH_SUBPIX_AVG_VAR(64, 32)
HIGHBD_VAR(64, 32)
HIGHBD_SUBPIX_VAR(64, 32)
HIGHBD_SUBPIX_AVG_VAR(64, 32)
HIGH_VAR(64, 64)
HIGH_SUBPIX_VAR(64, 64)
HIGH_SUBPIX_AVG_VAR(64, 64)
HIGHBD_VAR(64, 64)
HIGHBD_SUBPIX_VAR(64, 64)
HIGHBD_SUBPIX_AVG_VAR(64, 64)
void vp9_high_comp_avg_pred(uint16_t *comp_pred, const uint8_t *pred8,
int width, int height, const uint8_t *ref8,
int ref_stride) {
void vp9_highbd_comp_avg_pred(uint16_t *comp_pred, const uint8_t *pred8,
int width, int height, const uint8_t *ref8,
int ref_stride) {
int i, j;
uint16_t *pred = CONVERT_TO_SHORTPTR(pred8);
uint16_t *ref = CONVERT_TO_SHORTPTR(ref8);

29
vp9/encoder/vp9_variance.h
Просмотреть файл

@ -23,20 +23,20 @@ void variance(const uint8_t *a, int a_stride,
unsigned int *sse, int *sum);
#if CONFIG_VP9_HIGHBITDEPTH
void high_variance(const uint8_t *a8, int a_stride,
const uint8_t *b8, int b_stride,
int w, int h,
unsigned int *sse, int *sum);
void highbd_variance(const uint8_t *a8, int a_stride,
const uint8_t *b8, int b_stride,
int w, int h,
unsigned int *sse, int *sum);
void high_10_variance(const uint8_t *a8, int a_stride,
const uint8_t *b8, int b_stride,
int w, int h,
unsigned int *sse, int *sum);
void highbd_10_variance(const uint8_t *a8, int a_stride,
const uint8_t *b8, int b_stride,
int w, int h,
unsigned int *sse, int *sum);
void high_12_variance(const uint8_t *a8, int a_stride,
const uint8_t *b8, int b_stride,
int w, int h,
unsigned int *sse, int *sum);
void highbd_12_variance(const uint8_t *a8, int a_stride,
const uint8_t *b8, int b_stride,
int w, int h,
unsigned int *sse, int *sum);
#endif
typedef unsigned int(*vp9_sad_fn_t)(const uint8_t *src_ptr,
@ -99,8 +99,9 @@ void vp9_comp_avg_pred(uint8_t *comp_pred, const uint8_t *pred, int width,
int height, const uint8_t *ref, int ref_stride);
#if CONFIG_VP9_HIGHBITDEPTH
void vp9_high_comp_avg_pred(uint16_t *comp_pred, const uint8_t *pred, int width,
int height, const uint8_t *ref, int ref_stride);
void vp9_highbd_comp_avg_pred(uint16_t *comp_pred, const uint8_t *pred,
int width, int height,
const uint8_t *ref, int ref_stride);
#endif
#ifdef __cplusplus