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
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
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
+/*
+ * 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
* 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"
#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> {
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();
}
}
}
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() {
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();
}
}
}
INSTANTIATE_TEST_CASE_P(C, CopyFrameTest,
::testing::Values(vp8_yv12_copy_frame_c));
-} // namespace
+
+} // namespace libvpx_test
--- /dev/null
+/*
+ * 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_
#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) {
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,
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) {
projects / libvpx / commitdiff