ref: d5d2cbcc758d8b735d2aba25663914185d11cada
parent: 7219f3190402d1dbbfc7eeab07baf9bd13e6ea6f
author: Linfeng Zhang <linfengz@google.com>
date: Tue Sep 5 10:38:45 EDT 2017
Add ScaleFrameTest Move class VpxScaleBase to new file test/vpx_scale_test.h. Add new file test/vp9_scale_test.cc with ScaleFrameTest. BUG=webm:1419 Change-Id: Iec2098eafcef99b94047de525e5da47bcab519c1
--- a/test/test.mk
+++ b/test/test.mk
@@ -123,6 +123,7 @@
LIBVPX_TEST_SRCS-yes += idct_test.cc
LIBVPX_TEST_SRCS-yes += predict_test.cc
LIBVPX_TEST_SRCS-yes += vpx_scale_test.cc
+LIBVPX_TEST_SRCS-yes += vpx_scale_test.h
ifeq ($(CONFIG_VP8_ENCODER)$(CONFIG_TEMPORAL_DENOISING),yesyes)
LIBVPX_TEST_SRCS-$(HAVE_SSE2) += vp8_denoiser_sse2_test.cc
@@ -158,6 +159,7 @@
LIBVPX_TEST_SRCS-$(CONFIG_VP9_ENCODER) += fdct8x8_test.cc
LIBVPX_TEST_SRCS-$(CONFIG_VP9_ENCODER) += hadamard_test.cc
LIBVPX_TEST_SRCS-$(CONFIG_VP9_ENCODER) += minmax_test.cc
+LIBVPX_TEST_SRCS-$(CONFIG_VP9_ENCODER) += vp9_scale_test.cc
ifneq ($(CONFIG_REALTIME_ONLY),yes)
LIBVPX_TEST_SRCS-$(CONFIG_VP9_ENCODER) += temporal_filter_test.cc
endif
--- /dev/null
+++ b/test/vp9_scale_test.cc
@@ -1,0 +1,189 @@
+/*
+ * Copyright (c) 2017 The WebM project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "third_party/googletest/src/include/gtest/gtest.h"
+
+#include "./vp9_rtcd.h"
+#include "./vpx_config.h"
+#include "./vpx_scale_rtcd.h"
+#include "test/clear_system_state.h"
+#include "test/register_state_check.h"
+#include "test/vpx_scale_test.h"
+#include "vpx_mem/vpx_mem.h"
+#include "vpx_ports/vpx_timer.h"
+#include "vpx_scale/yv12config.h"
+
+namespace libvpx_test {+
+typedef void (*ScaleFrameFunc)(const YV12_BUFFER_CONFIG *src,
+ YV12_BUFFER_CONFIG *dst,
+ INTERP_FILTER filter_type, int phase_scaler);
+
+class ScaleTest : public VpxScaleBase,
+ public ::testing::TestWithParam<ScaleFrameFunc> {+ public:
+ virtual ~ScaleTest() {}+
+ protected:
+ virtual void SetUp() { scale_fn_ = GetParam(); }+
+ void ReferenceScaleFrame(INTERP_FILTER filter_type, int phase_scaler) {+ vp9_scale_and_extend_frame_c(&img_, &ref_img_, filter_type, phase_scaler);
+ }
+
+ void ScaleFrame(INTERP_FILTER filter_type, int phase_scaler) {+ ASM_REGISTER_STATE_CHECK(
+ scale_fn_(&img_, &dst_img_, filter_type, phase_scaler));
+ }
+
+ void RunTest() {+ static const int kNumSizesToTest = 4;
+ static const int kNumScaleFactorsToTest = 2;
+ static const int kWidthsToTest[] = { 16, 32, 48, 64 };+ static const int kHeightsToTest[] = { 16, 20, 24, 28 };+ static const int kScaleFactors[] = { 1, 2 };+ for (INTERP_FILTER filter_type = 0; filter_type < 4; ++filter_type) {+ for (int phase_scaler = 0; phase_scaler < 16; ++phase_scaler) {+ for (int h = 0; h < kNumSizesToTest; ++h) {+ const int src_height = kHeightsToTest[h];
+ for (int w = 0; w < kNumSizesToTest; ++w) {+ const int src_width = kWidthsToTest[w];
+ for (int sf_up_idx = 0; sf_up_idx < kNumScaleFactorsToTest;
+ ++sf_up_idx) {+ const int sf_up = kScaleFactors[sf_up_idx];
+ for (int sf_down_idx = 0; sf_down_idx < kNumScaleFactorsToTest;
+ ++sf_down_idx) {+ const int sf_down = kScaleFactors[sf_down_idx];
+ const int dst_width = src_width * sf_up / sf_down;
+ const int dst_height = src_height * sf_up / sf_down;
+ if (sf_up == sf_down && sf_up != 1) {+ continue;
+ }
+ // I420 frame width and height must be even.
+ if (dst_width & 1 || dst_height & 1) {+ continue;
+ }
+ ASSERT_NO_FATAL_FAILURE(ResetScaleImages(
+ src_width, src_height, dst_width, dst_height));
+ ReferenceScaleFrame(filter_type, phase_scaler);
+ ScaleFrame(filter_type, phase_scaler);
+ PrintDiff();
+ CompareImages(dst_img_);
+ DeallocScaleImages();
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ void PrintDiffComponent(const uint8_t *const ref, const uint8_t *const opt,
+ const int stride, const int width, const int height,
+ const int plane_idx) const {+ for (int y = 0; y < height; y++) {+ for (int x = 0; x < width; x++) {+ if (ref[y * stride + x] != opt[y * stride + x]) {+ printf("Plane %d pixel[%d][%d] diff:%6d (ref),%6d (opt)\n", plane_idx,+ y, x, ref[y * stride + x], opt[y * stride + x]);
+ break;
+ }
+ }
+ }
+ }
+
+ void PrintDiff() const {+ assert(ref_img_.y_stride == dst_img_.y_stride);
+ assert(ref_img_.y_width == dst_img_.y_width);
+ assert(ref_img_.y_height == dst_img_.y_height);
+ assert(ref_img_.uv_stride == dst_img_.uv_stride);
+ assert(ref_img_.uv_width == dst_img_.uv_width);
+ assert(ref_img_.uv_height == dst_img_.uv_height);
+
+ if (memcmp(dst_img_.buffer_alloc, ref_img_.buffer_alloc,
+ ref_img_.frame_size)) {+ PrintDiffComponent(ref_img_.y_buffer, dst_img_.y_buffer,
+ ref_img_.y_stride, ref_img_.y_width, ref_img_.y_height,
+ 0);
+ PrintDiffComponent(ref_img_.u_buffer, dst_img_.u_buffer,
+ ref_img_.uv_stride, ref_img_.uv_width,
+ ref_img_.uv_height, 1);
+ PrintDiffComponent(ref_img_.v_buffer, dst_img_.v_buffer,
+ ref_img_.uv_stride, ref_img_.uv_width,
+ ref_img_.uv_height, 2);
+ }
+ }
+
+ ScaleFrameFunc scale_fn_;
+};
+
+TEST_P(ScaleTest, ScaleFrame) { ASSERT_NO_FATAL_FAILURE(RunTest()); }+
+TEST_P(ScaleTest, DISABLED_Speed) {+ static const int kCountSpeedTestBlock = 100;
+ static const int kNumScaleFactorsToTest = 2;
+ static const int kScaleFactors[] = { 1, 2 };+ const int src_height = 1280;
+ const int src_width = 720;
+ for (INTERP_FILTER filter_type = 2; filter_type < 4; ++filter_type) {+ for (int phase_scaler = 0; phase_scaler < 2; ++phase_scaler) {+ for (int sf_up_idx = 0; sf_up_idx < kNumScaleFactorsToTest; ++sf_up_idx) {+ const int sf_up = kScaleFactors[sf_up_idx];
+ for (int sf_down_idx = 0; sf_down_idx < kNumScaleFactorsToTest;
+ ++sf_down_idx) {+ const int sf_down = kScaleFactors[sf_down_idx];
+ const int dst_width = src_width * sf_up / sf_down;
+ const int dst_height = src_height * sf_up / sf_down;
+ if (sf_up == sf_down && sf_up != 1) {+ continue;
+ }
+ // I420 frame width and height must be even.
+ if (dst_width & 1 || dst_height & 1) {+ continue;
+ }
+ ASSERT_NO_FATAL_FAILURE(
+ ResetScaleImages(src_width, src_height, dst_width, dst_height));
+ ASM_REGISTER_STATE_CHECK(
+ ReferenceScaleFrame(filter_type, phase_scaler));
+
+ vpx_usec_timer timer;
+ vpx_usec_timer_start(&timer);
+ for (int i = 0; i < kCountSpeedTestBlock; ++i) {+ ScaleFrame(filter_type, phase_scaler);
+ }
+ libvpx_test::ClearSystemState();
+ vpx_usec_timer_mark(&timer);
+ const int elapsed_time =
+ static_cast<int>(vpx_usec_timer_elapsed(&timer) / 1000);
+ CompareImages(dst_img_);
+ DeallocScaleImages();
+
+ printf(
+ "filter_type = %d, phase_scaler = %d, src_width = %4d, "
+ "src_height = %4d, dst_width = %4d, dst_height = %4d, "
+ "scale factor = %d:%d, scale time: %5d ms\n",
+ filter_type, phase_scaler, src_width, src_height, dst_width,
+ dst_height, sf_down, sf_up, elapsed_time);
+ }
+ }
+ }
+ }
+}
+
+#if HAVE_SSSE3
+INSTANTIATE_TEST_CASE_P(SSSE3, ScaleTest,
+ ::testing::Values(vp9_scale_and_extend_frame_ssse3));
+#endif // HAVE_SSSE3
+
+} // namespace libvpx_test
--- a/test/vpx_scale_test.cc
+++ b/test/vpx_scale_test.cc
@@ -8,6 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
+#include <stdio.h>
+
#include "third_party/googletest/src/include/gtest/gtest.h"
#include "./vpx_config.h"
@@ -14,149 +16,17 @@
#include "./vpx_scale_rtcd.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
+#include "test/vpx_scale_test.h"
#include "vpx_mem/vpx_mem.h"
+#include "vpx_ports/vpx_timer.h"
#include "vpx_scale/yv12config.h"
-namespace {+namespace libvpx_test {typedef void (*ExtendFrameBorderFunc)(YV12_BUFFER_CONFIG *ybf);
typedef void (*CopyFrameFunc)(const YV12_BUFFER_CONFIG *src_ybf,
YV12_BUFFER_CONFIG *dst_ybf);
-class VpxScaleBase {- public:
- virtual ~VpxScaleBase() { libvpx_test::ClearSystemState(); }-
- void ResetImage(int width, int height) {- width_ = width;
- height_ = height;
- memset(&img_, 0, sizeof(img_));
- ASSERT_EQ(0, vp8_yv12_alloc_frame_buffer(&img_, width_, height_,
- VP8BORDERINPIXELS));
- memset(img_.buffer_alloc, kBufFiller, img_.frame_size);
- FillPlane(img_.y_buffer, img_.y_crop_width, img_.y_crop_height,
- img_.y_stride);
- FillPlane(img_.u_buffer, img_.uv_crop_width, img_.uv_crop_height,
- img_.uv_stride);
- FillPlane(img_.v_buffer, img_.uv_crop_width, img_.uv_crop_height,
- img_.uv_stride);
-
- memset(&ref_img_, 0, sizeof(ref_img_));
- ASSERT_EQ(0, vp8_yv12_alloc_frame_buffer(&ref_img_, width_, height_,
- VP8BORDERINPIXELS));
- memset(ref_img_.buffer_alloc, kBufFiller, ref_img_.frame_size);
-
- memset(&cpy_img_, 0, sizeof(cpy_img_));
- ASSERT_EQ(0, vp8_yv12_alloc_frame_buffer(&cpy_img_, width_, height_,
- VP8BORDERINPIXELS));
- memset(cpy_img_.buffer_alloc, kBufFiller, cpy_img_.frame_size);
- ReferenceCopyFrame();
- }
-
- void DeallocImage() {- vp8_yv12_de_alloc_frame_buffer(&img_);
- vp8_yv12_de_alloc_frame_buffer(&ref_img_);
- vp8_yv12_de_alloc_frame_buffer(&cpy_img_);
- }
-
- protected:
- static const int kBufFiller = 123;
- static const int kBufMax = kBufFiller - 1;
-
- static void FillPlane(uint8_t *buf, int width, int height, int stride) {- for (int y = 0; y < height; ++y) {- for (int x = 0; x < width; ++x) {- buf[x + (y * stride)] = (x + (width * y)) % kBufMax;
- }
- }
- }
-
- static void ExtendPlane(uint8_t *buf, int crop_width, int crop_height,
- int width, int height, int stride, int padding) {- // Copy the outermost visible pixel to a distance of at least 'padding.'
- // The buffers are allocated such that there may be excess space outside the
- // padding. As long as the minimum amount of padding is achieved it is not
- // necessary to fill this space as well.
- uint8_t *left = buf - padding;
- uint8_t *right = buf + crop_width;
- const int right_extend = padding + (width - crop_width);
- const int bottom_extend = padding + (height - crop_height);
-
- // Fill the border pixels from the nearest image pixel.
- for (int y = 0; y < crop_height; ++y) {- memset(left, left[padding], padding);
- memset(right, right[-1], right_extend);
- left += stride;
- right += stride;
- }
-
- left = buf - padding;
- uint8_t *top = left - (stride * padding);
- // The buffer does not always extend as far as the stride.
- // Equivalent to padding + width + padding.
- const int extend_width = padding + crop_width + right_extend;
-
- // The first row was already extended to the left and right. Copy it up.
- for (int y = 0; y < padding; ++y) {- memcpy(top, left, extend_width);
- top += stride;
- }
-
- uint8_t *bottom = left + (crop_height * stride);
- for (int y = 0; y < bottom_extend; ++y) {- memcpy(bottom, left + (crop_height - 1) * stride, extend_width);
- bottom += stride;
- }
- }
-
- void ReferenceExtendBorder() {- ExtendPlane(ref_img_.y_buffer, ref_img_.y_crop_width,
- ref_img_.y_crop_height, ref_img_.y_width, ref_img_.y_height,
- ref_img_.y_stride, ref_img_.border);
- ExtendPlane(ref_img_.u_buffer, ref_img_.uv_crop_width,
- ref_img_.uv_crop_height, ref_img_.uv_width, ref_img_.uv_height,
- ref_img_.uv_stride, ref_img_.border / 2);
- ExtendPlane(ref_img_.v_buffer, ref_img_.uv_crop_width,
- ref_img_.uv_crop_height, ref_img_.uv_width, ref_img_.uv_height,
- ref_img_.uv_stride, ref_img_.border / 2);
- }
-
- void ReferenceCopyFrame() {- // Copy img_ to ref_img_ and extend frame borders. This will be used for
- // verifying extend_fn_ as well as copy_frame_fn_.
- EXPECT_EQ(ref_img_.frame_size, img_.frame_size);
- for (int y = 0; y < img_.y_crop_height; ++y) {- for (int x = 0; x < img_.y_crop_width; ++x) {- ref_img_.y_buffer[x + y * ref_img_.y_stride] =
- img_.y_buffer[x + y * img_.y_stride];
- }
- }
-
- for (int y = 0; y < img_.uv_crop_height; ++y) {- for (int x = 0; x < img_.uv_crop_width; ++x) {- ref_img_.u_buffer[x + y * ref_img_.uv_stride] =
- img_.u_buffer[x + y * img_.uv_stride];
- ref_img_.v_buffer[x + y * ref_img_.uv_stride] =
- img_.v_buffer[x + y * img_.uv_stride];
- }
- }
-
- ReferenceExtendBorder();
- }
-
- void CompareImages(const YV12_BUFFER_CONFIG actual) {- EXPECT_EQ(ref_img_.frame_size, actual.frame_size);
- EXPECT_EQ(0, memcmp(ref_img_.buffer_alloc, actual.buffer_alloc,
- ref_img_.frame_size));
- }
-
- YV12_BUFFER_CONFIG img_;
- YV12_BUFFER_CONFIG ref_img_;
- YV12_BUFFER_CONFIG cpy_img_;
- int width_;
- int height_;
-};
-
class ExtendBorderTest
: public VpxScaleBase,
public ::testing::TestWithParam<ExtendFrameBorderFunc> {@@ -178,11 +48,11 @@
static const int kSizesToTest[] = { 1, 15, 33, 145, 512, 1025, 16383 }; for (int h = 0; h < kNumSizesToTest; ++h) { for (int w = 0; w < kNumSizesToTest; ++w) {- ASSERT_NO_FATAL_FAILURE(ResetImage(kSizesToTest[w], kSizesToTest[h]));
+ ASSERT_NO_FATAL_FAILURE(ResetImages(kSizesToTest[w], kSizesToTest[h]));
+ ReferenceCopyFrame();
ExtendBorder();
- ReferenceExtendBorder();
CompareImages(img_);
- DeallocImage();
+ DeallocImages();
}
}
}
@@ -204,7 +74,7 @@
virtual void SetUp() { copy_frame_fn_ = GetParam(); } void CopyFrame() {- ASM_REGISTER_STATE_CHECK(copy_frame_fn_(&img_, &cpy_img_));
+ ASM_REGISTER_STATE_CHECK(copy_frame_fn_(&img_, &dst_img_));
}
void RunTest() {@@ -217,11 +87,11 @@
static const int kSizesToTest[] = { 1, 15, 33, 145, 512, 1025, 16383 }; for (int h = 0; h < kNumSizesToTest; ++h) { for (int w = 0; w < kNumSizesToTest; ++w) {- ASSERT_NO_FATAL_FAILURE(ResetImage(kSizesToTest[w], kSizesToTest[h]));
+ ASSERT_NO_FATAL_FAILURE(ResetImages(kSizesToTest[w], kSizesToTest[h]));
ReferenceCopyFrame();
CopyFrame();
- CompareImages(cpy_img_);
- DeallocImage();
+ CompareImages(dst_img_);
+ DeallocImages();
}
}
}
@@ -233,4 +103,5 @@
INSTANTIATE_TEST_CASE_P(C, CopyFrameTest,
::testing::Values(vp8_yv12_copy_frame_c));
-} // namespace
+
+} // namespace libvpx_test
--- /dev/null
+++ b/test/vpx_scale_test.h
@@ -1,0 +1,184 @@
+/*
+ * Copyright (c) 2014 The WebM project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef TEST_VPX_SCALE_TEST_H_
+#define TEST_VPX_SCALE_TEST_H_
+
+#include "third_party/googletest/src/include/gtest/gtest.h"
+
+#include "./vpx_config.h"
+#include "./vpx_scale_rtcd.h"
+#include "test/clear_system_state.h"
+#include "test/register_state_check.h"
+#include "vpx_mem/vpx_mem.h"
+#include "vpx_scale/yv12config.h"
+
+namespace libvpx_test {+
+class VpxScaleBase {+ public:
+ virtual ~VpxScaleBase() { libvpx_test::ClearSystemState(); }+
+ void ResetImage(YV12_BUFFER_CONFIG *const img, const int width,
+ const int height) {+ memset(img, 0, sizeof(*img));
+ ASSERT_EQ(
+ 0, vp8_yv12_alloc_frame_buffer(img, width, height, VP8BORDERINPIXELS));
+ memset(img->buffer_alloc, kBufFiller, img->frame_size);
+ }
+
+ void ResetImages(const int width, const int height) {+ ResetImage(&img_, width, height);
+ ResetImage(&ref_img_, width, height);
+ ResetImage(&dst_img_, width, height);
+
+ FillPlane(img_.y_buffer, img_.y_crop_width, img_.y_crop_height,
+ img_.y_stride);
+ FillPlane(img_.u_buffer, img_.uv_crop_width, img_.uv_crop_height,
+ img_.uv_stride);
+ FillPlane(img_.v_buffer, img_.uv_crop_width, img_.uv_crop_height,
+ img_.uv_stride);
+ }
+
+ void ResetScaleImage(YV12_BUFFER_CONFIG *const img, const int width,
+ const int height) {+ memset(img, 0, sizeof(*img));
+ ASSERT_EQ(0, vpx_alloc_frame_buffer(img, width, height, 1, 1,
+#if CONFIG_VP9_HIGHBITDEPTH
+ 0,
+#endif
+ VP9_ENC_BORDER_IN_PIXELS, 0));
+ memset(img->buffer_alloc, kBufFiller, img->frame_size);
+ }
+
+ void ResetScaleImages(const int src_width, const int src_height,
+ const int dst_width, const int dst_height) {+ ResetScaleImage(&img_, src_width, src_height);
+ ResetScaleImage(&ref_img_, dst_width, dst_height);
+ ResetScaleImage(&dst_img_, dst_width, dst_height);
+ FillPlane(img_.y_buffer, img_.y_crop_width, img_.y_crop_height,
+ img_.y_stride);
+ FillPlane(img_.u_buffer, img_.uv_crop_width, img_.uv_crop_height,
+ img_.uv_stride);
+ FillPlane(img_.v_buffer, img_.uv_crop_width, img_.uv_crop_height,
+ img_.uv_stride);
+ }
+
+ void DeallocImages() {+ vp8_yv12_de_alloc_frame_buffer(&img_);
+ vp8_yv12_de_alloc_frame_buffer(&ref_img_);
+ vp8_yv12_de_alloc_frame_buffer(&dst_img_);
+ }
+
+ void DeallocScaleImages() {+ vpx_free_frame_buffer(&img_);
+ vpx_free_frame_buffer(&ref_img_);
+ vpx_free_frame_buffer(&dst_img_);
+ }
+
+ protected:
+ static const int kBufFiller = 123;
+ static const int kBufMax = kBufFiller - 1;
+
+ static void FillPlane(uint8_t *buf, int width, int height, int stride) {+ for (int y = 0; y < height; ++y) {+ for (int x = 0; x < width; ++x) {+ buf[x + (y * stride)] = (x + (width * y)) % kBufMax;
+ }
+ }
+ }
+
+ static void ExtendPlane(uint8_t *buf, int crop_width, int crop_height,
+ int width, int height, int stride, int padding) {+ // Copy the outermost visible pixel to a distance of at least 'padding.'
+ // The buffers are allocated such that there may be excess space outside the
+ // padding. As long as the minimum amount of padding is achieved it is not
+ // necessary to fill this space as well.
+ uint8_t *left = buf - padding;
+ uint8_t *right = buf + crop_width;
+ const int right_extend = padding + (width - crop_width);
+ const int bottom_extend = padding + (height - crop_height);
+
+ // Fill the border pixels from the nearest image pixel.
+ for (int y = 0; y < crop_height; ++y) {+ memset(left, left[padding], padding);
+ memset(right, right[-1], right_extend);
+ left += stride;
+ right += stride;
+ }
+
+ left = buf - padding;
+ uint8_t *top = left - (stride * padding);
+ // The buffer does not always extend as far as the stride.
+ // Equivalent to padding + width + padding.
+ const int extend_width = padding + crop_width + right_extend;
+
+ // The first row was already extended to the left and right. Copy it up.
+ for (int y = 0; y < padding; ++y) {+ memcpy(top, left, extend_width);
+ top += stride;
+ }
+
+ uint8_t *bottom = left + (crop_height * stride);
+ for (int y = 0; y < bottom_extend; ++y) {+ memcpy(bottom, left + (crop_height - 1) * stride, extend_width);
+ bottom += stride;
+ }
+ }
+
+ void ReferenceExtendBorder() {+ ExtendPlane(ref_img_.y_buffer, ref_img_.y_crop_width,
+ ref_img_.y_crop_height, ref_img_.y_width, ref_img_.y_height,
+ ref_img_.y_stride, ref_img_.border);
+ ExtendPlane(ref_img_.u_buffer, ref_img_.uv_crop_width,
+ ref_img_.uv_crop_height, ref_img_.uv_width, ref_img_.uv_height,
+ ref_img_.uv_stride, ref_img_.border / 2);
+ ExtendPlane(ref_img_.v_buffer, ref_img_.uv_crop_width,
+ ref_img_.uv_crop_height, ref_img_.uv_width, ref_img_.uv_height,
+ ref_img_.uv_stride, ref_img_.border / 2);
+ }
+
+ void ReferenceCopyFrame() {+ // Copy img_ to ref_img_ and extend frame borders. This will be used for
+ // verifying extend_fn_ as well as copy_frame_fn_.
+ EXPECT_EQ(ref_img_.frame_size, img_.frame_size);
+ for (int y = 0; y < img_.y_crop_height; ++y) {+ for (int x = 0; x < img_.y_crop_width; ++x) {+ ref_img_.y_buffer[x + y * ref_img_.y_stride] =
+ img_.y_buffer[x + y * img_.y_stride];
+ }
+ }
+
+ for (int y = 0; y < img_.uv_crop_height; ++y) {+ for (int x = 0; x < img_.uv_crop_width; ++x) {+ ref_img_.u_buffer[x + y * ref_img_.uv_stride] =
+ img_.u_buffer[x + y * img_.uv_stride];
+ ref_img_.v_buffer[x + y * ref_img_.uv_stride] =
+ img_.v_buffer[x + y * img_.uv_stride];
+ }
+ }
+
+ ReferenceExtendBorder();
+ }
+
+ void CompareImages(const YV12_BUFFER_CONFIG actual) {+ EXPECT_EQ(ref_img_.frame_size, actual.frame_size);
+ EXPECT_EQ(0, memcmp(ref_img_.buffer_alloc, actual.buffer_alloc,
+ ref_img_.frame_size));
+ }
+
+ YV12_BUFFER_CONFIG img_;
+ YV12_BUFFER_CONFIG ref_img_;
+ YV12_BUFFER_CONFIG dst_img_;
+};
+
+} // namespace libvpx_test
+
+#endif // TEST_VPX_SCALE_TEST_H_
--- a/vp9/encoder/x86/vp9_frame_scale_ssse3.c
+++ b/vp9/encoder/x86/vp9_frame_scale_ssse3.c
@@ -15,10 +15,6 @@
#include "./vpx_scale_rtcd.h"
#include "vpx_scale/yv12config.h"
-extern void vp9_scale_and_extend_frame_c(const YV12_BUFFER_CONFIG *src,
- YV12_BUFFER_CONFIG *dst,
- uint8_t filter_type, int phase_scaler);
-
static void downsample_2_to_1_ssse3(const uint8_t *src, ptrdiff_t src_stride,
uint8_t *dst, ptrdiff_t dst_stride, int w,
int h) {@@ -45,6 +41,9 @@
const __m128i *const c, const __m128i *const d,
const __m128i *const e, const __m128i *const f,
const __m128i *const g, const __m128i *const h) {+ // TODO(linfengz): hard coded coefficients should be replaced with general
+ // coefficients
+ // reading.
const __m128i coeffs_ab =
_mm_set_epi8(6, -1, 6, -1, 6, -1, 6, -1, 6, -1, 6, -1, 6, -1, 6, -1);
const __m128i coeffs_cd = _mm_set_epi8(78, -19, 78, -19, 78, -19, 78, -19, 78,
@@ -186,7 +185,8 @@
downsample_2_to_1_ssse3(src->v_buffer, src->uv_stride, dst->v_buffer,
dst->uv_stride, dst_uv_w, dst_uv_h);
vpx_extend_frame_borders(dst);
- } else if (dst_w == src_w * 2 && dst_h == src_h * 2 && phase_scaler == 0) {+ } else if (dst_w == src_w * 2 && dst_h == src_h * 2 && filter_type == 0 &&
+ phase_scaler == 0) {// The upsample() supports widths up to 1920 * 2. If greater, fall back
// to vp9_scale_and_extend_frame_c().
if (dst_w / 2 <= 1920) {