| /* |
| * Copyright 2011 The LibYuv 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 <stdlib.h> |
| #include <time.h> |
| |
| #include "libyuv/basic_types.h" |
| #include "libyuv/compare.h" |
| #include "libyuv/convert.h" |
| #include "libyuv/convert_argb.h" |
| #include "libyuv/convert_from.h" |
| #include "libyuv/convert_from_argb.h" |
| #include "libyuv/cpu_id.h" |
| #ifdef HAVE_JPEG |
| #include "libyuv/mjpeg_decoder.h" |
| #endif |
| #include "libyuv/planar_functions.h" |
| #include "libyuv/rotate.h" |
| #include "libyuv/video_common.h" |
| #include "../unit_test/unit_test.h" |
| |
| namespace libyuv { |
| |
| #define SUBSAMPLE(v, a) ((((v) + (a) - 1)) / (a)) |
| |
| #define TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
| FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, W1280, N, NEG, OFF) \ |
| TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) { \ |
| const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ |
| const int kHeight = benchmark_height_; \ |
| align_buffer_page_end(src_y, kWidth * kHeight + OFF); \ |
| align_buffer_page_end(src_u, \ |
| SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + OFF); \ |
| align_buffer_page_end(src_v, \ |
| SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + OFF); \ |
| align_buffer_page_end(dst_y_c, kWidth * kHeight); \ |
| align_buffer_page_end(dst_u_c, \ |
| SUBSAMPLE(kWidth, SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| align_buffer_page_end(dst_v_c, \ |
| SUBSAMPLE(kWidth, SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| align_buffer_page_end(dst_y_opt, kWidth * kHeight); \ |
| align_buffer_page_end(dst_u_opt, \ |
| SUBSAMPLE(kWidth, SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| align_buffer_page_end(dst_v_opt, \ |
| SUBSAMPLE(kWidth, SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| for (int i = 0; i < kHeight; ++i) \ |
| for (int j = 0; j < kWidth; ++j) \ |
| src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ |
| for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ |
| for (int j = 0; j < SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ |
| src_u[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ |
| (fastrand() & 0xff); \ |
| src_v[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ |
| (fastrand() & 0xff); \ |
| } \ |
| } \ |
| memset(dst_y_c, 1, kWidth * kHeight); \ |
| memset(dst_u_c, 2, SUBSAMPLE(kWidth, SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| memset(dst_v_c, 3, SUBSAMPLE(kWidth, SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| memset(dst_y_opt, 101, kWidth * kHeight); \ |
| memset(dst_u_opt, 102, SUBSAMPLE(kWidth, SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| memset(dst_v_opt, 103, SUBSAMPLE(kWidth, SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| MaskCpuFlags(disable_cpu_flags_); \ |
| SRC_FMT_PLANAR##To##FMT_PLANAR(src_y + OFF, kWidth, \ |
| src_u + OFF, \ |
| SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ |
| src_v + OFF, \ |
| SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ |
| dst_y_c, kWidth, \ |
| dst_u_c, SUBSAMPLE(kWidth, SUBSAMP_X), \ |
| dst_v_c, SUBSAMPLE(kWidth, SUBSAMP_X), \ |
| kWidth, NEG kHeight); \ |
| MaskCpuFlags(benchmark_cpu_info_); \ |
| for (int i = 0; i < benchmark_iterations_; ++i) { \ |
| SRC_FMT_PLANAR##To##FMT_PLANAR(src_y + OFF, kWidth, \ |
| src_u + OFF, \ |
| SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ |
| src_v + OFF, \ |
| SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ |
| dst_y_opt, kWidth, \ |
| dst_u_opt, SUBSAMPLE(kWidth, SUBSAMP_X), \ |
| dst_v_opt, SUBSAMPLE(kWidth, SUBSAMP_X), \ |
| kWidth, NEG kHeight); \ |
| } \ |
| int max_diff = 0; \ |
| for (int i = 0; i < kHeight; ++i) { \ |
| for (int j = 0; j < kWidth; ++j) { \ |
| int abs_diff = \ |
| abs(static_cast<int>(dst_y_c[i * kWidth + j]) - \ |
| static_cast<int>(dst_y_opt[i * kWidth + j])); \ |
| if (abs_diff > max_diff) { \ |
| max_diff = abs_diff; \ |
| } \ |
| } \ |
| } \ |
| EXPECT_EQ(0, max_diff); \ |
| for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ |
| for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) { \ |
| int abs_diff = \ |
| abs(static_cast<int>(dst_u_c[i * \ |
| SUBSAMPLE(kWidth, SUBSAMP_X) + j]) - \ |
| static_cast<int>(dst_u_opt[i * \ |
| SUBSAMPLE(kWidth, SUBSAMP_X) + j])); \ |
| if (abs_diff > max_diff) { \ |
| max_diff = abs_diff; \ |
| } \ |
| } \ |
| } \ |
| EXPECT_LE(max_diff, 3); \ |
| for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ |
| for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) { \ |
| int abs_diff = \ |
| abs(static_cast<int>(dst_v_c[i * \ |
| SUBSAMPLE(kWidth, SUBSAMP_X) + j]) - \ |
| static_cast<int>(dst_v_opt[i * \ |
| SUBSAMPLE(kWidth, SUBSAMP_X) + j])); \ |
| if (abs_diff > max_diff) { \ |
| max_diff = abs_diff; \ |
| } \ |
| } \ |
| } \ |
| EXPECT_LE(max_diff, 3); \ |
| free_aligned_buffer_page_end(dst_y_c); \ |
| free_aligned_buffer_page_end(dst_u_c); \ |
| free_aligned_buffer_page_end(dst_v_c); \ |
| free_aligned_buffer_page_end(dst_y_opt); \ |
| free_aligned_buffer_page_end(dst_u_opt); \ |
| free_aligned_buffer_page_end(dst_v_opt); \ |
| free_aligned_buffer_page_end(src_y); \ |
| free_aligned_buffer_page_end(src_u); \ |
| free_aligned_buffer_page_end(src_v); \ |
| } |
| |
| #define TESTPLANARTOP(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
| FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y) \ |
| TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
| FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| benchmark_width_ - 4, _Any, +, 0) \ |
| TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
| FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| benchmark_width_, _Unaligned, +, 1) \ |
| TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
| FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| benchmark_width_, _Invert, -, 0) \ |
| TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
| FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| benchmark_width_, _Opt, +, 0) |
| |
| TESTPLANARTOP(I420, 2, 2, I420, 2, 2) |
| TESTPLANARTOP(I422, 2, 1, I420, 2, 2) |
| TESTPLANARTOP(I444, 1, 1, I420, 2, 2) |
| TESTPLANARTOP(I411, 4, 1, I420, 2, 2) |
| TESTPLANARTOP(I420, 2, 2, I422, 2, 1) |
| TESTPLANARTOP(I420, 2, 2, I444, 1, 1) |
| TESTPLANARTOP(I420, 2, 2, I411, 4, 1) |
| TESTPLANARTOP(I420, 2, 2, I420Mirror, 2, 2) |
| TESTPLANARTOP(I422, 2, 1, I422, 2, 1) |
| TESTPLANARTOP(I444, 1, 1, I444, 1, 1) |
| |
| #define TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
| FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, W1280, N, NEG, OFF) \ |
| TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) { \ |
| const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ |
| const int kHeight = benchmark_height_; \ |
| align_buffer_page_end(src_y, kWidth * kHeight + OFF); \ |
| align_buffer_page_end(src_u, \ |
| SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + OFF); \ |
| align_buffer_page_end(src_v, \ |
| SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + OFF); \ |
| align_buffer_page_end(dst_y_c, kWidth * kHeight); \ |
| align_buffer_page_end(dst_uv_c, SUBSAMPLE(kWidth * 2, SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| align_buffer_page_end(dst_y_opt, kWidth * kHeight); \ |
| align_buffer_page_end(dst_uv_opt, SUBSAMPLE(kWidth * 2, SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| for (int i = 0; i < kHeight; ++i) \ |
| for (int j = 0; j < kWidth; ++j) \ |
| src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ |
| for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ |
| for (int j = 0; j < SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ |
| src_u[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ |
| (fastrand() & 0xff); \ |
| src_v[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ |
| (fastrand() & 0xff); \ |
| } \ |
| } \ |
| memset(dst_y_c, 1, kWidth * kHeight); \ |
| memset(dst_uv_c, 2, SUBSAMPLE(kWidth * 2, SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| memset(dst_y_opt, 101, kWidth * kHeight); \ |
| memset(dst_uv_opt, 102, SUBSAMPLE(kWidth * 2, SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| MaskCpuFlags(disable_cpu_flags_); \ |
| SRC_FMT_PLANAR##To##FMT_PLANAR(src_y + OFF, kWidth, \ |
| src_u + OFF, \ |
| SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ |
| src_v + OFF, \ |
| SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ |
| dst_y_c, kWidth, \ |
| dst_uv_c, SUBSAMPLE(kWidth * 2, SUBSAMP_X), \ |
| kWidth, NEG kHeight); \ |
| MaskCpuFlags(benchmark_cpu_info_); \ |
| for (int i = 0; i < benchmark_iterations_; ++i) { \ |
| SRC_FMT_PLANAR##To##FMT_PLANAR(src_y + OFF, kWidth, \ |
| src_u + OFF, \ |
| SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ |
| src_v + OFF, \ |
| SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ |
| dst_y_opt, kWidth, \ |
| dst_uv_opt, \ |
| SUBSAMPLE(kWidth * 2, SUBSAMP_X), \ |
| kWidth, NEG kHeight); \ |
| } \ |
| int max_diff = 0; \ |
| for (int i = 0; i < kHeight; ++i) { \ |
| for (int j = 0; j < kWidth; ++j) { \ |
| int abs_diff = \ |
| abs(static_cast<int>(dst_y_c[i * kWidth + j]) - \ |
| static_cast<int>(dst_y_opt[i * kWidth + j])); \ |
| if (abs_diff > max_diff) { \ |
| max_diff = abs_diff; \ |
| } \ |
| } \ |
| } \ |
| EXPECT_LE(max_diff, 1); \ |
| for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ |
| for (int j = 0; j < SUBSAMPLE(kWidth * 2, SUBSAMP_X); ++j) { \ |
| int abs_diff = \ |
| abs(static_cast<int>(dst_uv_c[i * \ |
| SUBSAMPLE(kWidth * 2, SUBSAMP_X) + j]) - \ |
| static_cast<int>(dst_uv_opt[i * \ |
| SUBSAMPLE(kWidth * 2, SUBSAMP_X) + j])); \ |
| if (abs_diff > max_diff) { \ |
| max_diff = abs_diff; \ |
| } \ |
| } \ |
| } \ |
| EXPECT_LE(max_diff, 1); \ |
| free_aligned_buffer_page_end(dst_y_c); \ |
| free_aligned_buffer_page_end(dst_uv_c); \ |
| free_aligned_buffer_page_end(dst_y_opt); \ |
| free_aligned_buffer_page_end(dst_uv_opt); \ |
| free_aligned_buffer_page_end(src_y); \ |
| free_aligned_buffer_page_end(src_u); \ |
| free_aligned_buffer_page_end(src_v); \ |
| } |
| |
| #define TESTPLANARTOBP(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
| FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y) \ |
| TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
| FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| benchmark_width_ - 4, _Any, +, 0) \ |
| TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
| FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| benchmark_width_, _Unaligned, +, 1) \ |
| TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
| FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| benchmark_width_, _Invert, -, 0) \ |
| TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
| FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| benchmark_width_, _Opt, +, 0) |
| |
| TESTPLANARTOBP(I420, 2, 2, NV12, 2, 2) |
| TESTPLANARTOBP(I420, 2, 2, NV21, 2, 2) |
| |
| #define TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
| FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, W1280, N, NEG, OFF) \ |
| TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) { \ |
| const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ |
| const int kHeight = benchmark_height_; \ |
| align_buffer_page_end(src_y, kWidth * kHeight + OFF); \ |
| align_buffer_page_end(src_uv, 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + OFF); \ |
| align_buffer_page_end(dst_y_c, kWidth * kHeight); \ |
| align_buffer_page_end(dst_u_c, \ |
| SUBSAMPLE(kWidth, SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| align_buffer_page_end(dst_v_c, \ |
| SUBSAMPLE(kWidth, SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| align_buffer_page_end(dst_y_opt, kWidth * kHeight); \ |
| align_buffer_page_end(dst_u_opt, \ |
| SUBSAMPLE(kWidth, SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| align_buffer_page_end(dst_v_opt, \ |
| SUBSAMPLE(kWidth, SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| for (int i = 0; i < kHeight; ++i) \ |
| for (int j = 0; j < kWidth; ++j) \ |
| src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ |
| for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ |
| for (int j = 0; j < 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ |
| src_uv[(i * 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ |
| (fastrand() & 0xff); \ |
| } \ |
| } \ |
| memset(dst_y_c, 1, kWidth * kHeight); \ |
| memset(dst_u_c, 2, SUBSAMPLE(kWidth, SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| memset(dst_v_c, 3, SUBSAMPLE(kWidth, SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| memset(dst_y_opt, 101, kWidth * kHeight); \ |
| memset(dst_u_opt, 102, SUBSAMPLE(kWidth, SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| memset(dst_v_opt, 103, SUBSAMPLE(kWidth, SUBSAMP_X) * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| MaskCpuFlags(disable_cpu_flags_); \ |
| SRC_FMT_PLANAR##To##FMT_PLANAR(src_y + OFF, kWidth, \ |
| src_uv + OFF, \ |
| 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ |
| dst_y_c, kWidth, \ |
| dst_u_c, SUBSAMPLE(kWidth, SUBSAMP_X), \ |
| dst_v_c, SUBSAMPLE(kWidth, SUBSAMP_X), \ |
| kWidth, NEG kHeight); \ |
| MaskCpuFlags(benchmark_cpu_info_); \ |
| for (int i = 0; i < benchmark_iterations_; ++i) { \ |
| SRC_FMT_PLANAR##To##FMT_PLANAR(src_y + OFF, kWidth, \ |
| src_uv + OFF, \ |
| 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ |
| dst_y_opt, kWidth, \ |
| dst_u_opt, SUBSAMPLE(kWidth, SUBSAMP_X), \ |
| dst_v_opt, SUBSAMPLE(kWidth, SUBSAMP_X), \ |
| kWidth, NEG kHeight); \ |
| } \ |
| int max_diff = 0; \ |
| for (int i = 0; i < kHeight; ++i) { \ |
| for (int j = 0; j < kWidth; ++j) { \ |
| int abs_diff = \ |
| abs(static_cast<int>(dst_y_c[i * kWidth + j]) - \ |
| static_cast<int>(dst_y_opt[i * kWidth + j])); \ |
| if (abs_diff > max_diff) { \ |
| max_diff = abs_diff; \ |
| } \ |
| } \ |
| } \ |
| EXPECT_LE(max_diff, 1); \ |
| for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ |
| for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) { \ |
| int abs_diff = \ |
| abs(static_cast<int>(dst_u_c[i * \ |
| SUBSAMPLE(kWidth, SUBSAMP_X) + j]) - \ |
| static_cast<int>(dst_u_opt[i * \ |
| SUBSAMPLE(kWidth, SUBSAMP_X) + j])); \ |
| if (abs_diff > max_diff) { \ |
| max_diff = abs_diff; \ |
| } \ |
| } \ |
| } \ |
| EXPECT_LE(max_diff, 1); \ |
| for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ |
| for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) { \ |
| int abs_diff = \ |
| abs(static_cast<int>(dst_v_c[i * \ |
| SUBSAMPLE(kWidth, SUBSAMP_X) + j]) - \ |
| static_cast<int>(dst_v_opt[i * \ |
| SUBSAMPLE(kWidth, SUBSAMP_X) + j])); \ |
| if (abs_diff > max_diff) { \ |
| max_diff = abs_diff; \ |
| } \ |
| } \ |
| } \ |
| EXPECT_LE(max_diff, 1); \ |
| free_aligned_buffer_page_end(dst_y_c); \ |
| free_aligned_buffer_page_end(dst_u_c); \ |
| free_aligned_buffer_page_end(dst_v_c); \ |
| free_aligned_buffer_page_end(dst_y_opt); \ |
| free_aligned_buffer_page_end(dst_u_opt); \ |
| free_aligned_buffer_page_end(dst_v_opt); \ |
| free_aligned_buffer_page_end(src_y); \ |
| free_aligned_buffer_page_end(src_uv); \ |
| } |
| |
| #define TESTBIPLANARTOP(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
| FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y) \ |
| TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
| FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| benchmark_width_ - 4, _Any, +, 0) \ |
| TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
| FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| benchmark_width_, _Unaligned, +, 1) \ |
| TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
| FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| benchmark_width_, _Invert, -, 0) \ |
| TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
| FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| benchmark_width_, _Opt, +, 0) |
| |
| TESTBIPLANARTOP(NV12, 2, 2, I420, 2, 2) |
| TESTBIPLANARTOP(NV21, 2, 2, I420, 2, 2) |
| |
| #define ALIGNINT(V, ALIGN) (((V) + (ALIGN) - 1) / (ALIGN) * (ALIGN)) |
| |
| #define TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ |
| YALIGN, W1280, DIFF, N, NEG, OFF, FMT_C, BPP_C) \ |
| TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##N) { \ |
| const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ |
| const int kHeight = ALIGNINT(benchmark_height_, YALIGN); \ |
| const int kStrideB = ALIGNINT(kWidth * BPP_B, ALIGN); \ |
| const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ |
| const int kSizeUV = kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y); \ |
| align_buffer_page_end(src_y, kWidth * kHeight + OFF); \ |
| align_buffer_page_end(src_u, kSizeUV + OFF); \ |
| align_buffer_page_end(src_v, kSizeUV + OFF); \ |
| align_buffer_page_end(dst_argb_c, kStrideB * kHeight + OFF); \ |
| align_buffer_page_end(dst_argb_opt, kStrideB * kHeight + OFF); \ |
| for (int i = 0; i < kWidth * kHeight; ++i) { \ |
| src_y[i + OFF] = (fastrand() & 0xff); \ |
| } \ |
| for (int i = 0; i < kSizeUV; ++i) { \ |
| src_u[i + OFF] = (fastrand() & 0xff); \ |
| src_v[i + OFF] = (fastrand() & 0xff); \ |
| } \ |
| memset(dst_argb_c + OFF, 1, kStrideB * kHeight); \ |
| memset(dst_argb_opt + OFF, 101, kStrideB * kHeight); \ |
| MaskCpuFlags(disable_cpu_flags_); \ |
| FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, \ |
| src_u + OFF, kStrideUV, \ |
| src_v + OFF, kStrideUV, \ |
| dst_argb_c + OFF, kStrideB, \ |
| kWidth, NEG kHeight); \ |
| MaskCpuFlags(benchmark_cpu_info_); \ |
| for (int i = 0; i < benchmark_iterations_; ++i) { \ |
| FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, \ |
| src_u + OFF, kStrideUV, \ |
| src_v + OFF, kStrideUV, \ |
| dst_argb_opt + OFF, kStrideB, \ |
| kWidth, NEG kHeight); \ |
| } \ |
| int max_diff = 0; \ |
| /* Convert to ARGB so 565 is expanded to bytes that can be compared. */ \ |
| align_buffer_page_end(dst_argb32_c, kWidth * BPP_C * kHeight); \ |
| align_buffer_page_end(dst_argb32_opt, kWidth * BPP_C * kHeight); \ |
| memset(dst_argb32_c, 2, kWidth * BPP_C * kHeight); \ |
| memset(dst_argb32_opt, 102, kWidth * BPP_C * kHeight); \ |
| FMT_B##To##FMT_C(dst_argb_c + OFF, kStrideB, \ |
| dst_argb32_c, kWidth * BPP_C , \ |
| kWidth, kHeight); \ |
| FMT_B##To##FMT_C(dst_argb_opt + OFF, kStrideB, \ |
| dst_argb32_opt, kWidth * BPP_C , \ |
| kWidth, kHeight); \ |
| for (int i = 0; i < kWidth * BPP_C * kHeight; ++i) { \ |
| int abs_diff = \ |
| abs(static_cast<int>(dst_argb32_c[i]) - \ |
| static_cast<int>(dst_argb32_opt[i])); \ |
| if (abs_diff > max_diff) { \ |
| max_diff = abs_diff; \ |
| } \ |
| } \ |
| EXPECT_LE(max_diff, DIFF); \ |
| free_aligned_buffer_page_end(src_y); \ |
| free_aligned_buffer_page_end(src_u); \ |
| free_aligned_buffer_page_end(src_v); \ |
| free_aligned_buffer_page_end(dst_argb_c); \ |
| free_aligned_buffer_page_end(dst_argb_opt); \ |
| free_aligned_buffer_page_end(dst_argb32_c); \ |
| free_aligned_buffer_page_end(dst_argb32_opt); \ |
| } |
| |
| #define TESTPLANARTOB(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ |
| YALIGN, DIFF, FMT_C, BPP_C) \ |
| TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ |
| YALIGN, benchmark_width_ - 4, DIFF, _Any, +, 0, FMT_C, BPP_C) \ |
| TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ |
| YALIGN, benchmark_width_, DIFF, _Unaligned, +, 1, FMT_C, BPP_C) \ |
| TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ |
| YALIGN, benchmark_width_, DIFF, _Invert, -, 0, FMT_C, BPP_C) \ |
| TESTPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ |
| YALIGN, benchmark_width_, DIFF, _Opt, +, 0, FMT_C, BPP_C) |
| |
| TESTPLANARTOB(I420, 2, 2, ARGB, 4, 4, 1, 2, ARGB, 4) |
| TESTPLANARTOB(J420, 2, 2, ARGB, 4, 4, 1, 2, ARGB, 4) |
| TESTPLANARTOB(J420, 2, 2, ABGR, 4, 4, 1, 2, ARGB, 4) |
| TESTPLANARTOB(H420, 2, 2, ARGB, 4, 4, 1, 2, ARGB, 4) |
| TESTPLANARTOB(H420, 2, 2, ABGR, 4, 4, 1, 2, ARGB, 4) |
| TESTPLANARTOB(I420, 2, 2, BGRA, 4, 4, 1, 2, ARGB, 4) |
| TESTPLANARTOB(I420, 2, 2, ABGR, 4, 4, 1, 2, ARGB, 4) |
| TESTPLANARTOB(I420, 2, 2, RGBA, 4, 4, 1, 2, ARGB, 4) |
| TESTPLANARTOB(I420, 2, 2, RAW, 3, 3, 1, 2, ARGB, 4) |
| TESTPLANARTOB(I420, 2, 2, RGB24, 3, 3, 1, 2, ARGB, 4) |
| TESTPLANARTOB(I420, 2, 2, RGB565, 2, 2, 1, 9, ARGB, 4) |
| TESTPLANARTOB(I420, 2, 2, ARGB1555, 2, 2, 1, 9, ARGB, 4) |
| TESTPLANARTOB(I420, 2, 2, ARGB4444, 2, 2, 1, 17, ARGB, 4) |
| TESTPLANARTOB(I422, 2, 1, ARGB, 4, 4, 1, 2, ARGB, 4) |
| TESTPLANARTOB(J422, 2, 1, ARGB, 4, 4, 1, 2, ARGB, 4) |
| TESTPLANARTOB(J422, 2, 1, ABGR, 4, 4, 1, 2, ARGB, 4) |
| TESTPLANARTOB(H422, 2, 1, ARGB, 4, 4, 1, 2, ARGB, 4) |
| TESTPLANARTOB(H422, 2, 1, ABGR, 4, 4, 1, 2, ARGB, 4) |
| TESTPLANARTOB(I422, 2, 1, BGRA, 4, 4, 1, 2, ARGB, 4) |
| TESTPLANARTOB(I422, 2, 1, ABGR, 4, 4, 1, 2, ARGB, 4) |
| TESTPLANARTOB(I422, 2, 1, RGBA, 4, 4, 1, 2, ARGB, 4) |
| TESTPLANARTOB(I411, 4, 1, ARGB, 4, 4, 1, 2, ARGB, 4) |
| TESTPLANARTOB(I444, 1, 1, ARGB, 4, 4, 1, 2, ARGB, 4) |
| TESTPLANARTOB(J444, 1, 1, ARGB, 4, 4, 1, 2, ARGB, 4) |
| TESTPLANARTOB(I444, 1, 1, ABGR, 4, 4, 1, 2, ARGB, 4) |
| TESTPLANARTOB(I420, 2, 2, YUY2, 2, 4, 1, 1, ARGB, 4) |
| TESTPLANARTOB(I420, 2, 2, UYVY, 2, 4, 1, 1, ARGB, 4) |
| TESTPLANARTOB(I422, 2, 1, YUY2, 2, 4, 1, 0, ARGB, 4) |
| TESTPLANARTOB(I422, 2, 1, UYVY, 2, 4, 1, 0, ARGB, 4) |
| TESTPLANARTOB(I420, 2, 2, I400, 1, 1, 1, 0, ARGB, 4) |
| TESTPLANARTOB(J420, 2, 2, J400, 1, 1, 1, 0, ARGB, 4) |
| |
| #define TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ |
| YALIGN, W1280, DIFF, N, NEG, OFF, ATTEN) \ |
| TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##N) { \ |
| const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ |
| const int kHeight = ALIGNINT(benchmark_height_, YALIGN); \ |
| const int kStrideB = ALIGNINT(kWidth * BPP_B, ALIGN); \ |
| const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ |
| const int kSizeUV = kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y); \ |
| align_buffer_page_end(src_y, kWidth * kHeight + OFF); \ |
| align_buffer_page_end(src_u, kSizeUV + OFF); \ |
| align_buffer_page_end(src_v, kSizeUV + OFF); \ |
| align_buffer_page_end(src_a, kWidth * kHeight + OFF); \ |
| align_buffer_page_end(dst_argb_c, kStrideB * kHeight + OFF); \ |
| align_buffer_page_end(dst_argb_opt, kStrideB * kHeight + OFF); \ |
| for (int i = 0; i < kWidth * kHeight; ++i) { \ |
| src_y[i + OFF] = (fastrand() & 0xff); \ |
| src_a[i + OFF] = (fastrand() & 0xff); \ |
| } \ |
| for (int i = 0; i < kSizeUV; ++i) { \ |
| src_u[i + OFF] = (fastrand() & 0xff); \ |
| src_v[i + OFF] = (fastrand() & 0xff); \ |
| } \ |
| memset(dst_argb_c + OFF, 1, kStrideB * kHeight); \ |
| memset(dst_argb_opt + OFF, 101, kStrideB * kHeight); \ |
| MaskCpuFlags(disable_cpu_flags_); \ |
| FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, \ |
| src_u + OFF, kStrideUV, \ |
| src_v + OFF, kStrideUV, \ |
| src_a + OFF, kWidth, \ |
| dst_argb_c + OFF, kStrideB, \ |
| kWidth, NEG kHeight, ATTEN); \ |
| MaskCpuFlags(benchmark_cpu_info_); \ |
| for (int i = 0; i < benchmark_iterations_; ++i) { \ |
| FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, \ |
| src_u + OFF, kStrideUV, \ |
| src_v + OFF, kStrideUV, \ |
| src_a + OFF, kWidth, \ |
| dst_argb_opt + OFF, kStrideB, \ |
| kWidth, NEG kHeight, ATTEN); \ |
| } \ |
| int max_diff = 0; \ |
| for (int i = 0; i < kWidth * BPP_B * kHeight; ++i) { \ |
| int abs_diff = \ |
| abs(static_cast<int>(dst_argb_c[i + OFF]) - \ |
| static_cast<int>(dst_argb_opt[i + OFF])); \ |
| if (abs_diff > max_diff) { \ |
| max_diff = abs_diff; \ |
| } \ |
| } \ |
| EXPECT_LE(max_diff, DIFF); \ |
| free_aligned_buffer_page_end(src_y); \ |
| free_aligned_buffer_page_end(src_u); \ |
| free_aligned_buffer_page_end(src_v); \ |
| free_aligned_buffer_page_end(src_a); \ |
| free_aligned_buffer_page_end(dst_argb_c); \ |
| free_aligned_buffer_page_end(dst_argb_opt); \ |
| } |
| |
| #define TESTQPLANARTOB(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ |
| YALIGN, DIFF) \ |
| TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ |
| YALIGN, benchmark_width_ - 4, DIFF, _Any, +, 0, 0) \ |
| TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ |
| YALIGN, benchmark_width_, DIFF, _Unaligned, +, 1, 0) \ |
| TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ |
| YALIGN, benchmark_width_, DIFF, _Invert, -, 0, 0) \ |
| TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ |
| YALIGN, benchmark_width_, DIFF, _Opt, +, 0, 0) \ |
| TESTQPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ |
| YALIGN, benchmark_width_, DIFF, _Premult, +, 0, 1) |
| |
| TESTQPLANARTOB(I420Alpha, 2, 2, ARGB, 4, 4, 1, 2) |
| TESTQPLANARTOB(I420Alpha, 2, 2, ABGR, 4, 4, 1, 2) |
| |
| #define TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, \ |
| W1280, DIFF, N, NEG, OFF) \ |
| TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##N) { \ |
| const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ |
| const int kHeight = benchmark_height_; \ |
| const int kStrideB = kWidth * BPP_B; \ |
| const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ |
| align_buffer_page_end(src_y, kWidth * kHeight + OFF); \ |
| align_buffer_page_end(src_uv, \ |
| kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y) * 2 + OFF); \ |
| align_buffer_page_end(dst_argb_c, kStrideB * kHeight); \ |
| align_buffer_page_end(dst_argb_opt, kStrideB * kHeight); \ |
| for (int i = 0; i < kHeight; ++i) \ |
| for (int j = 0; j < kWidth; ++j) \ |
| src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ |
| for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ |
| for (int j = 0; j < kStrideUV * 2; ++j) { \ |
| src_uv[i * kStrideUV * 2 + j + OFF] = (fastrand() & 0xff); \ |
| } \ |
| } \ |
| memset(dst_argb_c, 1, kStrideB * kHeight); \ |
| memset(dst_argb_opt, 101, kStrideB * kHeight); \ |
| MaskCpuFlags(disable_cpu_flags_); \ |
| FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, \ |
| src_uv + OFF, kStrideUV * 2, \ |
| dst_argb_c, kWidth * BPP_B, \ |
| kWidth, NEG kHeight); \ |
| MaskCpuFlags(benchmark_cpu_info_); \ |
| for (int i = 0; i < benchmark_iterations_; ++i) { \ |
| FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, \ |
| src_uv + OFF, kStrideUV * 2, \ |
| dst_argb_opt, kWidth * BPP_B, \ |
| kWidth, NEG kHeight); \ |
| } \ |
| /* Convert to ARGB so 565 is expanded to bytes that can be compared. */ \ |
| align_buffer_page_end(dst_argb32_c, kWidth * 4 * kHeight); \ |
| align_buffer_page_end(dst_argb32_opt, kWidth * 4 * kHeight); \ |
| memset(dst_argb32_c, 2, kWidth * 4 * kHeight); \ |
| memset(dst_argb32_opt, 102, kWidth * 4 * kHeight); \ |
| FMT_B##ToARGB(dst_argb_c, kStrideB, \ |
| dst_argb32_c, kWidth * 4, \ |
| kWidth, kHeight); \ |
| FMT_B##ToARGB(dst_argb_opt, kStrideB, \ |
| dst_argb32_opt, kWidth * 4, \ |
| kWidth, kHeight); \ |
| int max_diff = 0; \ |
| for (int i = 0; i < kHeight; ++i) { \ |
| for (int j = 0; j < kWidth * 4; ++j) { \ |
| int abs_diff = \ |
| abs(static_cast<int>(dst_argb32_c[i * kWidth * 4 + j]) - \ |
| static_cast<int>(dst_argb32_opt[i * kWidth * 4 + j])); \ |
| if (abs_diff > max_diff) { \ |
| max_diff = abs_diff; \ |
| } \ |
| } \ |
| } \ |
| EXPECT_LE(max_diff, DIFF); \ |
| free_aligned_buffer_page_end(src_y); \ |
| free_aligned_buffer_page_end(src_uv); \ |
| free_aligned_buffer_page_end(dst_argb_c); \ |
| free_aligned_buffer_page_end(dst_argb_opt); \ |
| free_aligned_buffer_page_end(dst_argb32_c); \ |
| free_aligned_buffer_page_end(dst_argb32_opt); \ |
| } |
| |
| #define TESTBIPLANARTOB(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, DIFF) \ |
| TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, \ |
| benchmark_width_ - 4, DIFF, _Any, +, 0) \ |
| TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, \ |
| benchmark_width_, DIFF, _Unaligned, +, 1) \ |
| TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, \ |
| benchmark_width_, DIFF, _Invert, -, 0) \ |
| TESTBIPLANARTOBI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, \ |
| benchmark_width_, DIFF, _Opt, +, 0) |
| |
| TESTBIPLANARTOB(NV12, 2, 2, ARGB, 4, 2) |
| TESTBIPLANARTOB(NV21, 2, 2, ARGB, 4, 2) |
| TESTBIPLANARTOB(NV12, 2, 2, RGB565, 2, 9) |
| |
| #define TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| W1280, DIFF, N, NEG, OFF) \ |
| TEST_F(LibYUVConvertTest, FMT_A##To##FMT_PLANAR##N) { \ |
| const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ |
| const int kHeight = ALIGNINT(benchmark_height_, YALIGN); \ |
| const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ |
| const int kStride = \ |
| (kStrideUV * SUBSAMP_X * 8 * BPP_A + 7) / 8; \ |
| align_buffer_page_end(src_argb, kStride * kHeight + OFF); \ |
| align_buffer_page_end(dst_y_c, kWidth * kHeight); \ |
| align_buffer_page_end(dst_u_c, \ |
| kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| align_buffer_page_end(dst_v_c, \ |
| kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| align_buffer_page_end(dst_y_opt, kWidth * kHeight); \ |
| align_buffer_page_end(dst_u_opt, \ |
| kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| align_buffer_page_end(dst_v_opt, \ |
| kStrideUV * \ |
| SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| memset(dst_y_c, 1, kWidth * kHeight); \ |
| memset(dst_u_c, 2, \ |
| kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| memset(dst_v_c, 3, \ |
| kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| memset(dst_y_opt, 101, kWidth * kHeight); \ |
| memset(dst_u_opt, 102, \ |
| kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| memset(dst_v_opt, 103, \ |
| kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| for (int i = 0; i < kHeight; ++i) \ |
| for (int j = 0; j < kStride; ++j) \ |
| src_argb[(i * kStride) + j + OFF] = (fastrand() & 0xff); \ |
| MaskCpuFlags(disable_cpu_flags_); \ |
| FMT_A##To##FMT_PLANAR(src_argb + OFF, kStride, \ |
| dst_y_c, kWidth, \ |
| dst_u_c, kStrideUV, \ |
| dst_v_c, kStrideUV, \ |
| kWidth, NEG kHeight); \ |
| MaskCpuFlags(benchmark_cpu_info_); \ |
| for (int i = 0; i < benchmark_iterations_; ++i) { \ |
| FMT_A##To##FMT_PLANAR(src_argb + OFF, kStride, \ |
| dst_y_opt, kWidth, \ |
| dst_u_opt, kStrideUV, \ |
| dst_v_opt, kStrideUV, \ |
| kWidth, NEG kHeight); \ |
| } \ |
| for (int i = 0; i < kHeight; ++i) { \ |
| for (int j = 0; j < kWidth; ++j) { \ |
| EXPECT_NEAR(static_cast<int>(dst_y_c[i * kWidth + j]), \ |
| static_cast<int>(dst_y_opt[i * kWidth + j]), DIFF); \ |
| } \ |
| } \ |
| for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ |
| for (int j = 0; j < kStrideUV; ++j) { \ |
| EXPECT_NEAR(static_cast<int>(dst_u_c[i * kStrideUV + j]), \ |
| static_cast<int>(dst_u_opt[i * kStrideUV + j]), DIFF); \ |
| } \ |
| } \ |
| for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ |
| for (int j = 0; j < kStrideUV; ++j) { \ |
| EXPECT_NEAR(static_cast<int>(dst_v_c[i * \ |
| kStrideUV + j]), \ |
| static_cast<int>(dst_v_opt[i * \ |
| kStrideUV + j]), DIFF); \ |
| } \ |
| } \ |
| free_aligned_buffer_page_end(dst_y_c); \ |
| free_aligned_buffer_page_end(dst_u_c); \ |
| free_aligned_buffer_page_end(dst_v_c); \ |
| free_aligned_buffer_page_end(dst_y_opt); \ |
| free_aligned_buffer_page_end(dst_u_opt); \ |
| free_aligned_buffer_page_end(dst_v_opt); \ |
| free_aligned_buffer_page_end(src_argb); \ |
| } |
| |
| #define TESTATOPLANAR(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| DIFF) \ |
| TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| benchmark_width_ - 4, DIFF, _Any, +, 0) \ |
| TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| benchmark_width_, DIFF, _Unaligned, +, 1) \ |
| TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| benchmark_width_, DIFF, _Invert, -, 0) \ |
| TESTATOPLANARI(FMT_A, BPP_A, YALIGN, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| benchmark_width_, DIFF, _Opt, +, 0) |
| |
| TESTATOPLANAR(ARGB, 4, 1, I420, 2, 2, 4) |
| #if defined(__arm__) || defined (__aarch64__) |
| // arm version subsamples by summing 4 pixels then multiplying by matrix with |
| // 4x smaller coefficients which are rounded to nearest integer. |
| TESTATOPLANAR(ARGB, 4, 1, J420, 2, 2, 4) |
| TESTATOPLANAR(ARGB, 4, 1, J422, 2, 1, 4) |
| #else |
| TESTATOPLANAR(ARGB, 4, 1, J420, 2, 2, 0) |
| TESTATOPLANAR(ARGB, 4, 1, J422, 2, 1, 0) |
| #endif |
| TESTATOPLANAR(BGRA, 4, 1, I420, 2, 2, 4) |
| TESTATOPLANAR(ABGR, 4, 1, I420, 2, 2, 4) |
| TESTATOPLANAR(RGBA, 4, 1, I420, 2, 2, 4) |
| TESTATOPLANAR(RAW, 3, 1, I420, 2, 2, 4) |
| TESTATOPLANAR(RGB24, 3, 1, I420, 2, 2, 4) |
| TESTATOPLANAR(RGB565, 2, 1, I420, 2, 2, 5) |
| // TODO(fbarchard): Make 1555 neon work same as C code, reduce to diff 9. |
| TESTATOPLANAR(ARGB1555, 2, 1, I420, 2, 2, 15) |
| TESTATOPLANAR(ARGB4444, 2, 1, I420, 2, 2, 17) |
| TESTATOPLANAR(ARGB, 4, 1, I411, 4, 1, 4) |
| TESTATOPLANAR(ARGB, 4, 1, I422, 2, 1, 2) |
| TESTATOPLANAR(ARGB, 4, 1, I444, 1, 1, 2) |
| TESTATOPLANAR(YUY2, 2, 1, I420, 2, 2, 2) |
| TESTATOPLANAR(UYVY, 2, 1, I420, 2, 2, 2) |
| TESTATOPLANAR(YUY2, 2, 1, I422, 2, 1, 2) |
| TESTATOPLANAR(UYVY, 2, 1, I422, 2, 1, 2) |
| TESTATOPLANAR(I400, 1, 1, I420, 2, 2, 2) |
| TESTATOPLANAR(J400, 1, 1, J420, 2, 2, 2) |
| |
| #define TESTATOBIPLANARI(FMT_A, SUB_A, BPP_A, FMT_PLANAR, \ |
| SUBSAMP_X, SUBSAMP_Y, W1280, N, NEG, OFF) \ |
| TEST_F(LibYUVConvertTest, FMT_A##To##FMT_PLANAR##N) { \ |
| const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ |
| const int kHeight = benchmark_height_; \ |
| const int kStride = SUBSAMPLE(kWidth, SUB_A) * BPP_A; \ |
| const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ |
| align_buffer_page_end(src_argb, kStride * kHeight + OFF); \ |
| align_buffer_page_end(dst_y_c, kWidth * kHeight); \ |
| align_buffer_page_end(dst_uv_c, \ |
| kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| align_buffer_page_end(dst_y_opt, kWidth * kHeight); \ |
| align_buffer_page_end(dst_uv_opt, \ |
| kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| for (int i = 0; i < kHeight; ++i) \ |
| for (int j = 0; j < kStride; ++j) \ |
| src_argb[(i * kStride) + j + OFF] = (fastrand() & 0xff); \ |
| memset(dst_y_c, 1, kWidth * kHeight); \ |
| memset(dst_uv_c, 2, kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| memset(dst_y_opt, 101, kWidth * kHeight); \ |
| memset(dst_uv_opt, 102, kStrideUV * 2 * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
| MaskCpuFlags(disable_cpu_flags_); \ |
| FMT_A##To##FMT_PLANAR(src_argb + OFF, kStride, \ |
| dst_y_c, kWidth, dst_uv_c, kStrideUV * 2, \ |
| kWidth, NEG kHeight); \ |
| MaskCpuFlags(benchmark_cpu_info_); \ |
| for (int i = 0; i < benchmark_iterations_; ++i) { \ |
| FMT_A##To##FMT_PLANAR(src_argb + OFF, kStride, \ |
| dst_y_opt, kWidth, \ |
| dst_uv_opt, kStrideUV * 2, kWidth, NEG kHeight); \ |
| } \ |
| int max_diff = 0; \ |
| for (int i = 0; i < kHeight; ++i) { \ |
| for (int j = 0; j < kWidth; ++j) { \ |
| int abs_diff = \ |
| abs(static_cast<int>(dst_y_c[i * kWidth + j]) - \ |
| static_cast<int>(dst_y_opt[i * kWidth + j])); \ |
| if (abs_diff > max_diff) { \ |
| max_diff = abs_diff; \ |
| } \ |
| } \ |
| } \ |
| EXPECT_LE(max_diff, 4); \ |
| for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ |
| for (int j = 0; j < kStrideUV * 2; ++j) { \ |
| int abs_diff = \ |
| abs(static_cast<int>(dst_uv_c[i * kStrideUV * 2 + j]) - \ |
| static_cast<int>(dst_uv_opt[i * kStrideUV * 2 + j])); \ |
| if (abs_diff > max_diff) { \ |
| max_diff = abs_diff; \ |
| } \ |
| } \ |
| } \ |
| EXPECT_LE(max_diff, 4); \ |
| free_aligned_buffer_page_end(dst_y_c); \ |
| free_aligned_buffer_page_end(dst_uv_c); \ |
| free_aligned_buffer_page_end(dst_y_opt); \ |
| free_aligned_buffer_page_end(dst_uv_opt); \ |
| free_aligned_buffer_page_end(src_argb); \ |
| } |
| |
| #define TESTATOBIPLANAR(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y) \ |
| TESTATOBIPLANARI(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| benchmark_width_ - 4, _Any, +, 0) \ |
| TESTATOBIPLANARI(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| benchmark_width_, _Unaligned, +, 1) \ |
| TESTATOBIPLANARI(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| benchmark_width_, _Invert, -, 0) \ |
| TESTATOBIPLANARI(FMT_A, SUB_A, BPP_A, FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, \ |
| benchmark_width_, _Opt, +, 0) |
| |
| TESTATOBIPLANAR(ARGB, 1, 4, NV12, 2, 2) |
| TESTATOBIPLANAR(ARGB, 1, 4, NV21, 2, 2) |
| TESTATOBIPLANAR(YUY2, 2, 4, NV12, 2, 2) |
| TESTATOBIPLANAR(UYVY, 2, 4, NV12, 2, 2) |
| |
| #define TESTATOBI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ |
| FMT_B, BPP_B, STRIDE_B, HEIGHT_B, \ |
| W1280, DIFF, N, NEG, OFF) \ |
| TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##N) { \ |
| const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ |
| const int kHeight = benchmark_height_; \ |
| const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A; \ |
| const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B; \ |
| const int kStrideA = (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A; \ |
| const int kStrideB = (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B; \ |
| align_buffer_page_end(src_argb, kStrideA * kHeightA + OFF); \ |
| align_buffer_page_end(dst_argb_c, kStrideB * kHeightB); \ |
| align_buffer_page_end(dst_argb_opt, kStrideB * kHeightB); \ |
| for (int i = 0; i < kStrideA * kHeightA; ++i) { \ |
| src_argb[i + OFF] = (fastrand() & 0xff); \ |
| } \ |
| memset(dst_argb_c, 1, kStrideB * kHeightB); \ |
| memset(dst_argb_opt, 101, kStrideB * kHeightB); \ |
| MaskCpuFlags(disable_cpu_flags_); \ |
| FMT_A##To##FMT_B(src_argb + OFF, kStrideA, \ |
| dst_argb_c, kStrideB, \ |
| kWidth, NEG kHeight); \ |
| MaskCpuFlags(benchmark_cpu_info_); \ |
| for (int i = 0; i < benchmark_iterations_; ++i) { \ |
| FMT_A##To##FMT_B(src_argb + OFF, kStrideA, \ |
| dst_argb_opt, kStrideB, \ |
| kWidth, NEG kHeight); \ |
| } \ |
| int max_diff = 0; \ |
| for (int i = 0; i < kStrideB * kHeightB; ++i) { \ |
| int abs_diff = \ |
| abs(static_cast<int>(dst_argb_c[i]) - \ |
| static_cast<int>(dst_argb_opt[i])); \ |
| if (abs_diff > max_diff) { \ |
| max_diff = abs_diff; \ |
| } \ |
| } \ |
| EXPECT_LE(max_diff, DIFF); \ |
| free_aligned_buffer_page_end(src_argb); \ |
| free_aligned_buffer_page_end(dst_argb_c); \ |
| free_aligned_buffer_page_end(dst_argb_opt); \ |
| } |
| |
| #define TESTATOBRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ |
| FMT_B, BPP_B, STRIDE_B, HEIGHT_B, DIFF) \ |
| TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##_Random) { \ |
| for (int times = 0; times < benchmark_iterations_; ++times) { \ |
| const int kWidth = (fastrand() & 63) + 1; \ |
| const int kHeight = (fastrand() & 31) + 1; \ |
| const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A; \ |
| const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B; \ |
| const int kStrideA = (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A;\ |
| const int kStrideB = (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B;\ |
| align_buffer_page_end(src_argb, kStrideA * kHeightA); \ |
| align_buffer_page_end(dst_argb_c, kStrideB * kHeightB); \ |
| align_buffer_page_end(dst_argb_opt, kStrideB * kHeightB); \ |
| for (int i = 0; i < kStrideA * kHeightA; ++i) { \ |
| src_argb[i] = (fastrand() & 0xff); \ |
| } \ |
| memset(dst_argb_c, 123, kStrideB * kHeightB); \ |
| memset(dst_argb_opt, 123, kStrideB * kHeightB); \ |
| MaskCpuFlags(disable_cpu_flags_); \ |
| FMT_A##To##FMT_B(src_argb, kStrideA, \ |
| dst_argb_c, kStrideB, \ |
| kWidth, kHeight); \ |
| MaskCpuFlags(benchmark_cpu_info_); \ |
| FMT_A##To##FMT_B(src_argb, kStrideA, \ |
| dst_argb_opt, kStrideB, \ |
| kWidth, kHeight); \ |
| int max_diff = 0; \ |
| for (int i = 0; i < kStrideB * kHeightB; ++i) { \ |
| int abs_diff = \ |
| abs(static_cast<int>(dst_argb_c[i]) - \ |
| static_cast<int>(dst_argb_opt[i])); \ |
| if (abs_diff > max_diff) { \ |
| max_diff = abs_diff; \ |
| } \ |
| } \ |
| EXPECT_LE(max_diff, DIFF); \ |
| free_aligned_buffer_page_end(src_argb); \ |
| free_aligned_buffer_page_end(dst_argb_c); \ |
| free_aligned_buffer_page_end(dst_argb_opt); \ |
| } \ |
| } |
| |
| #define TESTATOB(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ |
| FMT_B, BPP_B, STRIDE_B, HEIGHT_B, DIFF) \ |
| TESTATOBI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ |
| FMT_B, BPP_B, STRIDE_B, HEIGHT_B, \ |
| benchmark_width_ - 4, DIFF, _Any, +, 0) \ |
| TESTATOBI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ |
| FMT_B, BPP_B, STRIDE_B, HEIGHT_B, \ |
| benchmark_width_, DIFF, _Unaligned, +, 1) \ |
| TESTATOBI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ |
| FMT_B, BPP_B, STRIDE_B, HEIGHT_B, \ |
| benchmark_width_, DIFF, _Invert, -, 0) \ |
| TESTATOBI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ |
| FMT_B, BPP_B, STRIDE_B, HEIGHT_B, \ |
| benchmark_width_, DIFF, _Opt, +, 0) \ |
| TESTATOBRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ |
| FMT_B, BPP_B, STRIDE_B, HEIGHT_B, DIFF) |
| |
| TESTATOB(ARGB, 4, 4, 1, ARGB, 4, 4, 1, 0) |
| TESTATOB(ARGB, 4, 4, 1, BGRA, 4, 4, 1, 0) |
| TESTATOB(ARGB, 4, 4, 1, ABGR, 4, 4, 1, 0) |
| TESTATOB(ARGB, 4, 4, 1, RGBA, 4, 4, 1, 0) |
| TESTATOB(ARGB, 4, 4, 1, RAW, 3, 3, 1, 0) |
| TESTATOB(ARGB, 4, 4, 1, RGB24, 3, 3, 1, 0) |
| TESTATOB(ARGB, 4, 4, 1, RGB565, 2, 2, 1, 0) |
| TESTATOB(ARGB, 4, 4, 1, ARGB1555, 2, 2, 1, 0) |
| TESTATOB(ARGB, 4, 4, 1, ARGB4444, 2, 2, 1, 0) |
| TESTATOB(ARGB, 4, 4, 1, YUY2, 2, 4, 1, 4) |
| TESTATOB(ARGB, 4, 4, 1, UYVY, 2, 4, 1, 4) |
| TESTATOB(ARGB, 4, 4, 1, I400, 1, 1, 1, 2) |
| TESTATOB(ARGB, 4, 4, 1, J400, 1, 1, 1, 2) |
| TESTATOB(BGRA, 4, 4, 1, ARGB, 4, 4, 1, 0) |
| TESTATOB(ABGR, 4, 4, 1, ARGB, 4, 4, 1, 0) |
| TESTATOB(RGBA, 4, 4, 1, ARGB, 4, 4, 1, 0) |
| TESTATOB(RAW, 3, 3, 1, ARGB, 4, 4, 1, 0) |
| TESTATOB(RAW, 3, 3, 1, RGB24, 3, 3, 1, 0) |
| TESTATOB(RGB24, 3, 3, 1, ARGB, 4, 4, 1, 0) |
| TESTATOB(RGB565, 2, 2, 1, ARGB, 4, 4, 1, 0) |
| TESTATOB(ARGB1555, 2, 2, 1, ARGB, 4, 4, 1, 0) |
| TESTATOB(ARGB4444, 2, 2, 1, ARGB, 4, 4, 1, 0) |
| TESTATOB(YUY2, 2, 4, 1, ARGB, 4, 4, 1, 4) |
| TESTATOB(UYVY, 2, 4, 1, ARGB, 4, 4, 1, 4) |
| TESTATOB(I400, 1, 1, 1, ARGB, 4, 4, 1, 0) |
| TESTATOB(J400, 1, 1, 1, ARGB, 4, 4, 1, 0) |
| TESTATOB(I400, 1, 1, 1, I400, 1, 1, 1, 0) |
| TESTATOB(J400, 1, 1, 1, J400, 1, 1, 1, 0) |
| TESTATOB(I400, 1, 1, 1, I400Mirror, 1, 1, 1, 0) |
| TESTATOB(ARGB, 4, 4, 1, ARGBMirror, 4, 4, 1, 0) |
| |
| #define TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ |
| FMT_B, BPP_B, STRIDE_B, HEIGHT_B, \ |
| W1280, DIFF, N, NEG, OFF) \ |
| TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##Dither##N) { \ |
| const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ |
| const int kHeight = benchmark_height_; \ |
| const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A; \ |
| const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B; \ |
| const int kStrideA = (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A; \ |
| const int kStrideB = (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B; \ |
| align_buffer_page_end(src_argb, kStrideA * kHeightA + OFF); \ |
| align_buffer_page_end(dst_argb_c, kStrideB * kHeightB); \ |
| align_buffer_page_end(dst_argb_opt, kStrideB * kHeightB); \ |
| for (int i = 0; i < kStrideA * kHeightA; ++i) { \ |
| src_argb[i + OFF] = (fastrand() & 0xff); \ |
| } \ |
| memset(dst_argb_c, 1, kStrideB * kHeightB); \ |
| memset(dst_argb_opt, 101, kStrideB * kHeightB); \ |
| MaskCpuFlags(disable_cpu_flags_); \ |
| FMT_A##To##FMT_B##Dither(src_argb + OFF, kStrideA, \ |
| dst_argb_c, kStrideB, \ |
| NULL, kWidth, NEG kHeight); \ |
| MaskCpuFlags(benchmark_cpu_info_); \ |
| for (int i = 0; i < benchmark_iterations_; ++i) { \ |
| FMT_A##To##FMT_B##Dither(src_argb + OFF, kStrideA, \ |
| dst_argb_opt, kStrideB, \ |
| NULL, kWidth, NEG kHeight); \ |
| } \ |
| int max_diff = 0; \ |
| for (int i = 0; i < kStrideB * kHeightB; ++i) { \ |
| int abs_diff = \ |
| abs(static_cast<int>(dst_argb_c[i]) - \ |
| static_cast<int>(dst_argb_opt[i])); \ |
| if (abs_diff > max_diff) { \ |
| max_diff = abs_diff; \ |
| } \ |
| } \ |
| EXPECT_LE(max_diff, DIFF); \ |
| free_aligned_buffer_page_end(src_argb); \ |
| free_aligned_buffer_page_end(dst_argb_c); \ |
| free_aligned_buffer_page_end(dst_argb_opt); \ |
| } |
| |
| #define TESTATOBDRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ |
| FMT_B, BPP_B, STRIDE_B, HEIGHT_B, DIFF) \ |
| TEST_F(LibYUVConvertTest, FMT_A##To##FMT_B##Dither_Random) { \ |
| for (int times = 0; times < benchmark_iterations_; ++times) { \ |
| const int kWidth = (fastrand() & 63) + 1; \ |
| const int kHeight = (fastrand() & 31) + 1; \ |
| const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A; \ |
| const int kHeightB = (kHeight + HEIGHT_B - 1) / HEIGHT_B * HEIGHT_B; \ |
| const int kStrideA = (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A;\ |
| const int kStrideB = (kWidth * BPP_B + STRIDE_B - 1) / STRIDE_B * STRIDE_B;\ |
| align_buffer_page_end(src_argb, kStrideA * kHeightA); \ |
| align_buffer_page_end(dst_argb_c, kStrideB * kHeightB); \ |
| align_buffer_page_end(dst_argb_opt, kStrideB * kHeightB); \ |
| for (int i = 0; i < kStrideA * kHeightA; ++i) { \ |
| src_argb[i] = (fastrand() & 0xff); \ |
| } \ |
| memset(dst_argb_c, 123, kStrideB * kHeightB); \ |
| memset(dst_argb_opt, 123, kStrideB * kHeightB); \ |
| MaskCpuFlags(disable_cpu_flags_); \ |
| FMT_A##To##FMT_B##Dither(src_argb, kStrideA, \ |
| dst_argb_c, kStrideB, \ |
| NULL, kWidth, kHeight); \ |
| MaskCpuFlags(benchmark_cpu_info_); \ |
| FMT_A##To##FMT_B##Dither(src_argb, kStrideA, \ |
| dst_argb_opt, kStrideB, \ |
| NULL, kWidth, kHeight); \ |
| int max_diff = 0; \ |
| for (int i = 0; i < kStrideB * kHeightB; ++i) { \ |
| int abs_diff = \ |
| abs(static_cast<int>(dst_argb_c[i]) - \ |
| static_cast<int>(dst_argb_opt[i])); \ |
| if (abs_diff > max_diff) { \ |
| max_diff = abs_diff; \ |
| } \ |
| } \ |
| EXPECT_LE(max_diff, DIFF); \ |
| free_aligned_buffer_page_end(src_argb); \ |
| free_aligned_buffer_page_end(dst_argb_c); \ |
| free_aligned_buffer_page_end(dst_argb_opt); \ |
| } \ |
| } |
| |
| #define TESTATOBD(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ |
| FMT_B, BPP_B, STRIDE_B, HEIGHT_B, DIFF) \ |
| TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ |
| FMT_B, BPP_B, STRIDE_B, HEIGHT_B, \ |
| benchmark_width_ - 4, DIFF, _Any, +, 0) \ |
| TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ |
| FMT_B, BPP_B, STRIDE_B, HEIGHT_B, \ |
| benchmark_width_, DIFF, _Unaligned, +, 1) \ |
| TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ |
| FMT_B, BPP_B, STRIDE_B, HEIGHT_B, \ |
| benchmark_width_, DIFF, _Invert, -, 0) \ |
| TESTATOBDI(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ |
| FMT_B, BPP_B, STRIDE_B, HEIGHT_B, \ |
| benchmark_width_, DIFF, _Opt, +, 0) \ |
| TESTATOBDRANDOM(FMT_A, BPP_A, STRIDE_A, HEIGHT_A, \ |
| FMT_B, BPP_B, STRIDE_B, HEIGHT_B, DIFF) |
| |
| TESTATOBD(ARGB, 4, 4, 1, RGB565, 2, 2, 1, 0) |
| |
| #define TESTSYMI(FMT_ATOB, BPP_A, STRIDE_A, HEIGHT_A, \ |
| W1280, N, NEG, OFF) \ |
| TEST_F(LibYUVConvertTest, FMT_ATOB##_Symetric##N) { \ |
| const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ |
| const int kHeight = benchmark_height_; \ |
| const int kHeightA = (kHeight + HEIGHT_A - 1) / HEIGHT_A * HEIGHT_A; \ |
| const int kStrideA = (kWidth * BPP_A + STRIDE_A - 1) / STRIDE_A * STRIDE_A; \ |
| align_buffer_page_end(src_argb, kStrideA * kHeightA + OFF); \ |
| align_buffer_page_end(dst_argb_c, kStrideA * kHeightA); \ |
| align_buffer_page_end(dst_argb_opt, kStrideA * kHeightA); \ |
| for (int i = 0; i < kStrideA * kHeightA; ++i) { \ |
| src_argb[i + OFF] = (fastrand() & 0xff); \ |
| } \ |
| memset(dst_argb_c, 1, kStrideA * kHeightA); \ |
| memset(dst_argb_opt, 101, kStrideA * kHeightA); \ |
| MaskCpuFlags(disable_cpu_flags_); \ |
| FMT_ATOB(src_argb + OFF, kStrideA, \ |
| dst_argb_c, kStrideA, \ |
| kWidth, NEG kHeight); \ |
| MaskCpuFlags(benchmark_cpu_info_); \ |
| for (int i = 0; i < benchmark_iterations_; ++i) { \ |
| FMT_ATOB(src_argb + OFF, kStrideA, \ |
| dst_argb_opt, kStrideA, \ |
| kWidth, NEG kHeight); \ |
| } \ |
| MaskCpuFlags(disable_cpu_flags_); \ |
| FMT_ATOB(dst_argb_c, kStrideA, \ |
| dst_argb_c, kStrideA, \ |
| kWidth, NEG kHeight); \ |
| MaskCpuFlags(benchmark_cpu_info_); \ |
| FMT_ATOB(dst_argb_opt, kStrideA, \ |
| dst_argb_opt, kStrideA, \ |
| kWidth, NEG kHeight); \ |
| for (int i = 0; i < kStrideA * kHeightA; ++i) { \ |
| EXPECT_EQ(src_argb[i + OFF], dst_argb_opt[i]); \ |
| EXPECT_EQ(dst_argb_c[i], dst_argb_opt[i]); \ |
| } \ |
| free_aligned_buffer_page_end(src_argb); \ |
| free_aligned_buffer_page_end(dst_argb_c); \ |
| free_aligned_buffer_page_end(dst_argb_opt); \ |
| } |
| |
| #define TESTSYM(FMT_ATOB, BPP_A, STRIDE_A, HEIGHT_A) \ |
| TESTSYMI(FMT_ATOB, BPP_A, STRIDE_A, HEIGHT_A, \ |
| benchmark_width_ - 4, _Any, +, 0) \ |
| TESTSYMI(FMT_ATOB, BPP_A, STRIDE_A, HEIGHT_A, \ |
| benchmark_width_, _Unaligned, +, 1) \ |
| TESTSYMI(FMT_ATOB, BPP_A, STRIDE_A, HEIGHT_A, \ |
| benchmark_width_, _Opt, +, 0) |
| |
| TESTSYM(ARGBToARGB, 4, 4, 1) |
| TESTSYM(ARGBToBGRA, 4, 4, 1) |
| TESTSYM(ARGBToABGR, 4, 4, 1) |
| TESTSYM(BGRAToARGB, 4, 4, 1) |
| TESTSYM(ABGRToARGB, 4, 4, 1) |
| |
| TEST_F(LibYUVConvertTest, Test565) { |
| SIMD_ALIGNED(uint8 orig_pixels[256][4]); |
| SIMD_ALIGNED(uint8 pixels565[256][2]); |
| |
| for (int i = 0; i < 256; ++i) { |
| for (int j = 0; j < 4; ++j) { |
| orig_pixels[i][j] = i; |
| } |
| } |
| ARGBToRGB565(&orig_pixels[0][0], 0, &pixels565[0][0], 0, 256, 1); |
| uint32 checksum = HashDjb2(&pixels565[0][0], sizeof(pixels565), 5381); |
| EXPECT_EQ(610919429u, checksum); |
| } |
| |
| #ifdef HAVE_JPEG |
| TEST_F(LibYUVConvertTest, ValidateJpeg) { |
| const int kOff = 10; |
| const int kMinJpeg = 64; |
| const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg ? |
| benchmark_width_ * benchmark_height_ : kMinJpeg; |
| const int kSize = kImageSize + kOff; |
| align_buffer_page_end(orig_pixels, kSize); |
| |
| // No SOI or EOI. Expect fail. |
| memset(orig_pixels, 0, kSize); |
| EXPECT_FALSE(ValidateJpeg(orig_pixels, kSize)); |
| |
| // Test special value that matches marker start. |
| memset(orig_pixels, 0xff, kSize); |
| EXPECT_FALSE(ValidateJpeg(orig_pixels, kSize)); |
| |
| // EOI, SOI. Expect pass. |
| orig_pixels[0] = 0xff; |
| orig_pixels[1] = 0xd8; // SOI. |
| orig_pixels[kSize - kOff + 0] = 0xff; |
| orig_pixels[kSize - kOff + 1] = 0xd9; // EOI. |
| for (int times = 0; times < benchmark_iterations_; ++times) { |
| EXPECT_TRUE(ValidateJpeg(orig_pixels, kSize)); |
| } |
| free_aligned_buffer_page_end(orig_pixels); |
| } |
| |
| TEST_F(LibYUVConvertTest, ValidateJpegLarge) { |
| const int kOff = 10; |
| const int kMinJpeg = 64; |
| const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg ? |
| benchmark_width_ * benchmark_height_ : kMinJpeg; |
| const int kSize = kImageSize + kOff; |
| const int kMultiple = 10; |
| const int kBufSize = kImageSize * kMultiple + kOff; |
| align_buffer_page_end(orig_pixels, kBufSize); |
| |
| // No SOI or EOI. Expect fail. |
| memset(orig_pixels, 0, kBufSize); |
| EXPECT_FALSE(ValidateJpeg(orig_pixels, kBufSize)); |
| |
| // EOI, SOI. Expect pass. |
| orig_pixels[0] = 0xff; |
| orig_pixels[1] = 0xd8; // SOI. |
| orig_pixels[kSize - kOff + 0] = 0xff; |
| orig_pixels[kSize - kOff + 1] = 0xd9; // EOI. |
| for (int times = 0; times < benchmark_iterations_; ++times) { |
| EXPECT_TRUE(ValidateJpeg(orig_pixels, kBufSize)); |
| } |
| free_aligned_buffer_page_end(orig_pixels); |
| } |
| |
| TEST_F(LibYUVConvertTest, InvalidateJpeg) { |
| const int kOff = 10; |
| const int kMinJpeg = 64; |
| const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg ? |
| benchmark_width_ * benchmark_height_ : kMinJpeg; |
| const int kSize = kImageSize + kOff; |
| align_buffer_page_end(orig_pixels, kSize); |
| |
| // NULL pointer. Expect fail. |
| EXPECT_FALSE(ValidateJpeg(NULL, kSize)); |
| |
| // Negative size. Expect fail. |
| EXPECT_FALSE(ValidateJpeg(orig_pixels, -1)); |
| |
| // Too large size. Expect fail. |
| EXPECT_FALSE(ValidateJpeg(orig_pixels, 0xfb000000ull)); |
| |
| // No SOI or EOI. Expect fail. |
| memset(orig_pixels, 0, kSize); |
| EXPECT_FALSE(ValidateJpeg(orig_pixels, kSize)); |
| |
| // SOI but no EOI. Expect fail. |
| orig_pixels[0] = 0xff; |
| orig_pixels[1] = 0xd8; // SOI. |
| for (int times = 0; times < benchmark_iterations_; ++times) { |
| EXPECT_FALSE(ValidateJpeg(orig_pixels, kSize)); |
| } |
| |
| // EOI but no SOI. Expect fail. |
| orig_pixels[0] = 0; |
| orig_pixels[1] = 0; |
| orig_pixels[kSize - kOff + 0] = 0xff; |
| orig_pixels[kSize - kOff + 1] = 0xd9; // EOI. |
| EXPECT_FALSE(ValidateJpeg(orig_pixels, kSize)); |
| |
| free_aligned_buffer_page_end(orig_pixels); |
| } |
| |
| TEST_F(LibYUVConvertTest, FuzzJpeg) { |
| // SOI but no EOI. Expect fail. |
| for (int times = 0; times < benchmark_iterations_; ++times) { |
| const int kSize = fastrand() % 5000 + 2; |
| align_buffer_page_end(orig_pixels, kSize); |
| MemRandomize(orig_pixels, kSize); |
| |
| // Add SOI so frame will be scanned. |
| orig_pixels[0] = 0xff; |
| orig_pixels[1] = 0xd8; // SOI. |
| orig_pixels[kSize - 1] = 0xff; |
| ValidateJpeg(orig_pixels, kSize); // Failure normally expected. |
| free_aligned_buffer_page_end(orig_pixels); |
| } |
| } |
| |
| TEST_F(LibYUVConvertTest, MJPGToI420) { |
| const int kOff = 10; |
| const int kMinJpeg = 64; |
| const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg ? |
| benchmark_width_ * benchmark_height_ : kMinJpeg; |
| const int kSize = kImageSize + kOff; |
| align_buffer_page_end(orig_pixels, kSize); |
| align_buffer_page_end(dst_y_opt, benchmark_width_ * benchmark_height_); |
| align_buffer_page_end(dst_u_opt, |
| SUBSAMPLE(benchmark_width_, 2) * |
| SUBSAMPLE(benchmark_height_, 2)); |
| align_buffer_page_end(dst_v_opt, |
| SUBSAMPLE(benchmark_width_, 2) * |
| SUBSAMPLE(benchmark_height_, 2)); |
| |
| // EOI, SOI to make MJPG appear valid. |
| memset(orig_pixels, 0, kSize); |
| orig_pixels[0] = 0xff; |
| orig_pixels[1] = 0xd8; // SOI. |
| orig_pixels[kSize - kOff + 0] = 0xff; |
| orig_pixels[kSize - kOff + 1] = 0xd9; // EOI. |
| |
| for (int times = 0; times < benchmark_iterations_; ++times) { |
| int ret = MJPGToI420(orig_pixels, kSize, |
| dst_y_opt, benchmark_width_, |
| dst_u_opt, SUBSAMPLE(benchmark_width_, 2), |
| dst_v_opt, SUBSAMPLE(benchmark_width_, 2), |
| benchmark_width_, benchmark_height_, |
| benchmark_width_, benchmark_height_); |
| // Expect failure because image is not really valid. |
| EXPECT_EQ(1, ret); |
| } |
| |
| free_aligned_buffer_page_end(dst_y_opt); |
| free_aligned_buffer_page_end(dst_u_opt); |
| free_aligned_buffer_page_end(dst_v_opt); |
| free_aligned_buffer_page_end(orig_pixels); |
| } |
| |
| TEST_F(LibYUVConvertTest, MJPGToARGB) { |
| const int kOff = 10; |
| const int kMinJpeg = 64; |
| const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg ? |
| benchmark_width_ * benchmark_height_ : kMinJpeg; |
| const int kSize = kImageSize + kOff; |
| align_buffer_page_end(orig_pixels, kSize); |
| align_buffer_page_end(dst_argb_opt, benchmark_width_ * benchmark_height_ * 4); |
| |
| // EOI, SOI to make MJPG appear valid. |
| memset(orig_pixels, 0, kSize); |
| orig_pixels[0] = 0xff; |
| orig_pixels[1] = 0xd8; // SOI. |
| orig_pixels[kSize - kOff + 0] = 0xff; |
| orig_pixels[kSize - kOff + 1] = 0xd9; // EOI. |
| |
| for (int times = 0; times < benchmark_iterations_; ++times) { |
| int ret = MJPGToARGB(orig_pixels, kSize, |
| dst_argb_opt, benchmark_width_ * 4, |
| benchmark_width_, benchmark_height_, |
| benchmark_width_, benchmark_height_); |
| // Expect failure because image is not really valid. |
| EXPECT_EQ(1, ret); |
| } |
| |
| free_aligned_buffer_page_end(dst_argb_opt); |
| free_aligned_buffer_page_end(orig_pixels); |
| } |
| |
| #endif // HAVE_JPEG |
| |
| TEST_F(LibYUVConvertTest, NV12Crop) { |
| const int SUBSAMP_X = 2; |
| const int SUBSAMP_Y = 2; |
| const int kWidth = benchmark_width_; |
| const int kHeight = benchmark_height_; |
| const int crop_y = |
| ((benchmark_height_ - (benchmark_height_ * 360 / 480)) / 2 + 1) & ~1; |
| const int kDestWidth = benchmark_width_; |
| const int kDestHeight = benchmark_height_ - crop_y * 2; |
| const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); |
| const int sample_size = kWidth * kHeight + |
| kStrideUV * |
| SUBSAMPLE(kHeight, SUBSAMP_Y) * 2; |
| align_buffer_page_end(src_y, sample_size); |
| uint8* src_uv = src_y + kWidth * kHeight; |
| |
| align_buffer_page_end(dst_y, kDestWidth * kDestHeight); |
| align_buffer_page_end(dst_u, |
| SUBSAMPLE(kDestWidth, SUBSAMP_X) * |
| SUBSAMPLE(kDestHeight, SUBSAMP_Y)); |
| align_buffer_page_end(dst_v, |
| SUBSAMPLE(kDestWidth, SUBSAMP_X) * |
| SUBSAMPLE(kDestHeight, SUBSAMP_Y)); |
| |
| align_buffer_page_end(dst_y_2, kDestWidth * kDestHeight); |
| align_buffer_page_end(dst_u_2, |
| SUBSAMPLE(kDestWidth, SUBSAMP_X) * |
| SUBSAMPLE(kDestHeight, SUBSAMP_Y)); |
| align_buffer_page_end(dst_v_2, |
| SUBSAMPLE(kDestWidth, SUBSAMP_X) * |
| SUBSAMPLE(kDestHeight, SUBSAMP_Y)); |
| |
| for (int i = 0; i < kHeight * kWidth; ++i) { |
| src_y[i] = (fastrand() & 0xff); |
| } |
| for (int i = 0; i < (SUBSAMPLE(kHeight, SUBSAMP_Y) * |
| kStrideUV) * 2; ++i) { |
| src_uv[i] = (fastrand() & 0xff); |
| } |
| memset(dst_y, 1, kDestWidth * kDestHeight); |
| memset(dst_u, 2, SUBSAMPLE(kDestWidth, SUBSAMP_X) * |
| SUBSAMPLE(kDestHeight, SUBSAMP_Y)); |
| memset(dst_v, 3, SUBSAMPLE(kDestWidth, SUBSAMP_X) * |
| SUBSAMPLE(kDestHeight, SUBSAMP_Y)); |
| memset(dst_y_2, 1, kDestWidth * kDestHeight); |
| memset(dst_u_2, 2, SUBSAMPLE(kDestWidth, SUBSAMP_X) * |
| SUBSAMPLE(kDestHeight, SUBSAMP_Y)); |
| memset(dst_v_2, 3, SUBSAMPLE(kDestWidth, SUBSAMP_X) * |
| SUBSAMPLE(kDestHeight, SUBSAMP_Y)); |
| |
| ConvertToI420(src_y, sample_size, |
| dst_y_2, kDestWidth, |
| dst_u_2, SUBSAMPLE(kDestWidth, SUBSAMP_X), |
| dst_v_2, SUBSAMPLE(kDestWidth, SUBSAMP_X), |
| 0, crop_y, |
| kWidth, kHeight, |
| kDestWidth, kDestHeight, |
| libyuv::kRotate0, libyuv::FOURCC_NV12); |
| |
| NV12ToI420(src_y + crop_y * kWidth, kWidth, |
| src_uv + (crop_y / 2) * kStrideUV * 2, |
| kStrideUV * 2, |
| dst_y, kDestWidth, |
| dst_u, SUBSAMPLE(kDestWidth, SUBSAMP_X), |
| dst_v, SUBSAMPLE(kDestWidth, SUBSAMP_X), |
| kDestWidth, kDestHeight); |
| |
| for (int i = 0; i < kDestHeight; ++i) { |
| for (int j = 0; j < kDestWidth; ++j) { |
| EXPECT_EQ(dst_y[i * kWidth + j], dst_y_2[i * kWidth + j]); |
| } |
| } |
| for (int i = 0; i < SUBSAMPLE(kDestHeight, SUBSAMP_Y); ++i) { |
| for (int j = 0; j < SUBSAMPLE(kDestWidth, SUBSAMP_X); ++j) { |
| EXPECT_EQ(dst_u[i * SUBSAMPLE(kDestWidth, SUBSAMP_X) + j], |
| dst_u_2[i * SUBSAMPLE(kDestWidth, SUBSAMP_X) + j]); |
| } |
| } |
| for (int i = 0; i < SUBSAMPLE(kDestHeight, SUBSAMP_Y); ++i) { |
| for (int j = 0; j < SUBSAMPLE(kDestWidth, SUBSAMP_X); ++j) { |
| EXPECT_EQ(dst_v[i * SUBSAMPLE(kDestWidth, SUBSAMP_X) + j], |
| dst_v_2[i * SUBSAMPLE(kDestWidth, SUBSAMP_X) + j]); |
| } |
| } |
| free_aligned_buffer_page_end(dst_y); |
| free_aligned_buffer_page_end(dst_u); |
| free_aligned_buffer_page_end(dst_v); |
| free_aligned_buffer_page_end(dst_y_2); |
| free_aligned_buffer_page_end(dst_u_2); |
| free_aligned_buffer_page_end(dst_v_2); |
| free_aligned_buffer_page_end(src_y); |
| } |
| |
| TEST_F(LibYUVConvertTest, TestYToARGB) { |
| uint8 y[32]; |
| uint8 expectedg[32]; |
| for (int i = 0; i < 32; ++i) { |
| y[i] = i * 5 + 17; |
| expectedg[i] = static_cast<int>((y[i] - 16) * 1.164f + 0.5f); |
| } |
| uint8 argb[32 * 4]; |
| YToARGB(y, 0, argb, 0, 32, 1); |
| |
| for (int i = 0; i < 32; ++i) { |
| printf("%2d %d: %d <-> %d,%d,%d,%d\n", i, y[i], expectedg[i], |
| argb[i * 4 + 0], |
| argb[i * 4 + 1], |
| argb[i * 4 + 2], |
| argb[i * 4 + 3]); |
| } |
| for (int i = 0; i < 32; ++i) { |
| EXPECT_EQ(expectedg[i], argb[i * 4 + 0]); |
| } |
| } |
| |
| static const uint8 kNoDither4x4[16] = { |
| 0, 0, 0, 0, |
| 0, 0, 0, 0, |
| 0, 0, 0, 0, |
| 0, 0, 0, 0, |
| }; |
| |
| TEST_F(LibYUVConvertTest, TestNoDither) { |
| align_buffer_page_end(src_argb, benchmark_width_ * benchmark_height_ * 4); |
| align_buffer_page_end(dst_rgb565, benchmark_width_ * benchmark_height_ * 2); |
| align_buffer_page_end(dst_rgb565dither, |
| benchmark_width_ * benchmark_height_ * 2); |
| MemRandomize(src_argb, benchmark_width_ * benchmark_height_ * 4); |
| MemRandomize(dst_rgb565, benchmark_width_ * benchmark_height_ * 2); |
| MemRandomize(dst_rgb565dither, benchmark_width_ * benchmark_height_ * 2); |
| ARGBToRGB565(src_argb, benchmark_width_ * 4, |
| dst_rgb565, benchmark_width_ * 2, |
| benchmark_width_, benchmark_height_); |
| ARGBToRGB565Dither(src_argb, benchmark_width_ * 4, |
| dst_rgb565dither, benchmark_width_ * 2, |
| kNoDither4x4, benchmark_width_, benchmark_height_); |
| for (int i = 0; i < benchmark_width_ * benchmark_height_ * 2; ++i) { |
| EXPECT_EQ(dst_rgb565[i], dst_rgb565dither[i]); |
| } |
| |
| free_aligned_buffer_page_end(src_argb); |
| free_aligned_buffer_page_end(dst_rgb565); |
| free_aligned_buffer_page_end(dst_rgb565dither); |
| } |
| |
| // Ordered 4x4 dither for 888 to 565. Values from 0 to 7. |
| static const uint8 kDither565_4x4[16] = { |
| 0, 4, 1, 5, |
| 6, 2, 7, 3, |
| 1, 5, 0, 4, |
| 7, 3, 6, 2, |
| }; |
| |
| TEST_F(LibYUVConvertTest, TestDither) { |
| align_buffer_page_end(src_argb, benchmark_width_ * benchmark_height_ * 4); |
| align_buffer_page_end(dst_rgb565, benchmark_width_ * benchmark_height_ * 2); |
| align_buffer_page_end(dst_rgb565dither, |
| benchmark_width_ * benchmark_height_ * 2); |
| align_buffer_page_end(dst_argb, benchmark_width_ * benchmark_height_ * 4); |
| align_buffer_page_end(dst_argbdither, |
| benchmark_width_ * benchmark_height_ * 4); |
| MemRandomize(src_argb, benchmark_width_ * benchmark_height_ * 4); |
| MemRandomize(dst_rgb565, benchmark_width_ * benchmark_height_ * 2); |
| MemRandomize(dst_rgb565dither, benchmark_width_ * benchmark_height_ * 2); |
| MemRandomize(dst_argb, benchmark_width_ * benchmark_height_ * 4); |
| MemRandomize(dst_argbdither, benchmark_width_ * benchmark_height_ * 4); |
| ARGBToRGB565(src_argb, benchmark_width_ * 4, |
| dst_rgb565, benchmark_width_ * 2, |
| benchmark_width_, benchmark_height_); |
| ARGBToRGB565Dither(src_argb, benchmark_width_ * 4, |
| dst_rgb565dither, benchmark_width_ * 2, |
| kDither565_4x4, benchmark_width_, benchmark_height_); |
| RGB565ToARGB(dst_rgb565, benchmark_width_ * 2, |
| dst_argb, benchmark_width_ * 4, |
| benchmark_width_, benchmark_height_); |
| RGB565ToARGB(dst_rgb565dither, benchmark_width_ * 2, |
| dst_argbdither, benchmark_width_ * 4, |
| benchmark_width_, benchmark_height_); |
| |
| for (int i = 0; i < benchmark_width_ * benchmark_height_ * 4; ++i) { |
| EXPECT_NEAR(dst_argb[i], dst_argbdither[i], 9); |
| } |
| free_aligned_buffer_page_end(src_argb); |
| free_aligned_buffer_page_end(dst_rgb565); |
| free_aligned_buffer_page_end(dst_rgb565dither); |
| free_aligned_buffer_page_end(dst_argb); |
| free_aligned_buffer_page_end(dst_argbdither); |
| } |
| |
| #define TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ |
| YALIGN, W1280, DIFF, N, NEG, OFF, FMT_C, BPP_C) \ |
| TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##Dither##N) { \ |
| const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ |
| const int kHeight = ALIGNINT(benchmark_height_, YALIGN); \ |
| const int kStrideB = ALIGNINT(kWidth * BPP_B, ALIGN); \ |
| const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ |
| const int kSizeUV = kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y); \ |
| align_buffer_page_end(src_y, kWidth * kHeight + OFF); \ |
| align_buffer_page_end(src_u, kSizeUV + OFF); \ |
| align_buffer_page_end(src_v, kSizeUV + OFF); \ |
| align_buffer_page_end(dst_argb_c, kStrideB * kHeight + OFF); \ |
| align_buffer_page_end(dst_argb_opt, kStrideB * kHeight + OFF); \ |
| for (int i = 0; i < kWidth * kHeight; ++i) { \ |
| src_y[i + OFF] = (fastrand() & 0xff); \ |
| } \ |
| for (int i = 0; i < kSizeUV; ++i) { \ |
| src_u[i + OFF] = (fastrand() & 0xff); \ |
| src_v[i + OFF] = (fastrand() & 0xff); \ |
| } \ |
| memset(dst_argb_c + OFF, 1, kStrideB * kHeight); \ |
| memset(dst_argb_opt + OFF, 101, kStrideB * kHeight); \ |
| MaskCpuFlags(disable_cpu_flags_); \ |
| FMT_PLANAR##To##FMT_B##Dither(src_y + OFF, kWidth, \ |
| src_u + OFF, kStrideUV, \ |
| src_v + OFF, kStrideUV, \ |
| dst_argb_c + OFF, kStrideB, \ |
| NULL, kWidth, NEG kHeight); \ |
| MaskCpuFlags(benchmark_cpu_info_); \ |
| for (int i = 0; i < benchmark_iterations_; ++i) { \ |
| FMT_PLANAR##To##FMT_B##Dither(src_y + OFF, kWidth, \ |
| src_u + OFF, kStrideUV, \ |
| src_v + OFF, kStrideUV, \ |
| dst_argb_opt + OFF, kStrideB, \ |
| NULL, kWidth, NEG kHeight); \ |
| } \ |
| int max_diff = 0; \ |
| /* Convert to ARGB so 565 is expanded to bytes that can be compared. */ \ |
| align_buffer_page_end(dst_argb32_c, kWidth * BPP_C * kHeight); \ |
| align_buffer_page_end(dst_argb32_opt, kWidth * BPP_C * kHeight); \ |
| memset(dst_argb32_c, 2, kWidth * BPP_C * kHeight); \ |
| memset(dst_argb32_opt, 102, kWidth * BPP_C * kHeight); \ |
| FMT_B##To##FMT_C(dst_argb_c + OFF, kStrideB, \ |
| dst_argb32_c, kWidth * BPP_C , \ |
| kWidth, kHeight); \ |
| FMT_B##To##FMT_C(dst_argb_opt + OFF, kStrideB, \ |
| dst_argb32_opt, kWidth * BPP_C , \ |
| kWidth, kHeight); \ |
| for (int i = 0; i < kWidth * BPP_C * kHeight; ++i) { \ |
| int abs_diff = \ |
| abs(static_cast<int>(dst_argb32_c[i]) - \ |
| static_cast<int>(dst_argb32_opt[i])); \ |
| if (abs_diff > max_diff) { \ |
| max_diff = abs_diff; \ |
| } \ |
| } \ |
| EXPECT_LE(max_diff, DIFF); \ |
| free_aligned_buffer_page_end(src_y); \ |
| free_aligned_buffer_page_end(src_u); \ |
| free_aligned_buffer_page_end(src_v); \ |
| free_aligned_buffer_page_end(dst_argb_c); \ |
| free_aligned_buffer_page_end(dst_argb_opt); \ |
| free_aligned_buffer_page_end(dst_argb32_c); \ |
| free_aligned_buffer_page_end(dst_argb32_opt); \ |
| } |
| |
| #define TESTPLANARTOBD(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ |
| YALIGN, DIFF, FMT_C, BPP_C) \ |
| TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ |
| YALIGN, benchmark_width_ - 4, DIFF, _Any, +, 0, FMT_C, BPP_C) \ |
| TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ |
| YALIGN, benchmark_width_, DIFF, _Unaligned, +, 1, FMT_C, BPP_C) \ |
| TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ |
| YALIGN, benchmark_width_, DIFF, _Invert, -, 0, FMT_C, BPP_C) \ |
| TESTPLANARTOBID(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, BPP_B, ALIGN, \ |
| YALIGN, benchmark_width_, DIFF, _Opt, +, 0, FMT_C, BPP_C) |
| |
| TESTPLANARTOBD(I420, 2, 2, RGB565, 2, 2, 1, 9, ARGB, 4) |
| |
| #define TESTPTOB(NAME, UYVYTOI420, UYVYTONV12) \ |
| TEST_F(LibYUVConvertTest, NAME) { \ |
| const int kWidth = benchmark_width_; \ |
| const int kHeight = benchmark_height_; \ |
| \ |
| align_buffer_page_end(orig_uyvy, \ |
| 4 * SUBSAMPLE(kWidth, 2) * kHeight); \ |
| align_buffer_page_end(orig_y, kWidth * kHeight); \ |
| align_buffer_page_end(orig_u, \ |
| SUBSAMPLE(kWidth, 2) * \ |
| SUBSAMPLE(kHeight, 2)); \ |
| align_buffer_page_end(orig_v, \ |
| SUBSAMPLE(kWidth, 2) * \ |
| SUBSAMPLE(kHeight, 2)); \ |
| \ |
| align_buffer_page_end(dst_y_orig, kWidth * kHeight); \ |
| align_buffer_page_end(dst_uv_orig, 2 * \ |
| SUBSAMPLE(kWidth, 2) * \ |
| SUBSAMPLE(kHeight, 2)); \ |
| \ |
| align_buffer_page_end(dst_y, kWidth * kHeight); \ |
| align_buffer_page_end(dst_uv, 2 * \ |
| SUBSAMPLE(kWidth, 2) * \ |
| SUBSAMPLE(kHeight, 2)); \ |
| \ |
| MemRandomize(orig_uyvy, 4 * SUBSAMPLE(kWidth, 2) * kHeight); \ |
| \ |
| /* Convert UYVY to NV12 in 2 steps for reference */ \ |
| libyuv::UYVYTOI420(orig_uyvy, 4 * SUBSAMPLE(kWidth, 2), \ |
| orig_y, kWidth, \ |
| orig_u, SUBSAMPLE(kWidth, 2), \ |
| orig_v, SUBSAMPLE(kWidth, 2), \ |
| kWidth, kHeight); \ |
| libyuv::I420ToNV12(orig_y, kWidth, \ |
| orig_u, SUBSAMPLE(kWidth, 2), \ |
| orig_v, SUBSAMPLE(kWidth, 2), \ |
| dst_y_orig, kWidth, \ |
| dst_uv_orig, 2 * SUBSAMPLE(kWidth, 2), \ |
| kWidth, kHeight); \ |
| \ |
| /* Convert to NV12 */ \ |
| for (int i = 0; i < benchmark_iterations_; ++i) { \ |
| libyuv::UYVYTONV12(orig_uyvy, 4 * SUBSAMPLE(kWidth, 2), \ |
| dst_y, kWidth, \ |
| dst_uv, 2 * SUBSAMPLE(kWidth, 2), \ |
| kWidth, kHeight); \ |
| } \ |
| \ |
| for (int i = 0; i < kWidth * kHeight; ++i) { \ |
| EXPECT_EQ(orig_y[i], dst_y[i]); \ |
| } \ |
| for (int i = 0; i < kWidth * kHeight; ++i) { \ |
| EXPECT_EQ(dst_y_orig[i], dst_y[i]); \ |
| } \ |
| for (int i = 0; i < 2 * SUBSAMPLE(kWidth, 2) * SUBSAMPLE(kHeight, 2); ++i) { \ |
| EXPECT_EQ(dst_uv_orig[i], dst_uv[i]); \ |
| } \ |
| \ |
| free_aligned_buffer_page_end(orig_uyvy); \ |
| free_aligned_buffer_page_end(orig_y); \ |
| free_aligned_buffer_page_end(orig_u); \ |
| free_aligned_buffer_page_end(orig_v); \ |
| free_aligned_buffer_page_end(dst_y_orig); \ |
| free_aligned_buffer_page_end(dst_uv_orig); \ |
| free_aligned_buffer_page_end(dst_y); \ |
| free_aligned_buffer_page_end(dst_uv); \ |
| } |
| |
| TESTPTOB(TestYUY2ToNV12, YUY2ToI420, YUY2ToNV12) |
| TESTPTOB(TestUYVYToNV12, UYVYToI420, UYVYToNV12) |
| |
| #define TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ |
| W1280, N, NEG, OFF, FMT_C, BPP_C) \ |
| TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##_##FMT_C##N) { \ |
| const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ |
| const int kHeight = benchmark_height_; \ |
| const int kStrideB = SUBSAMPLE(kWidth, SUB_B) * BPP_B; \ |
| const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); \ |
| const int kSizeUV = kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y); \ |
| align_buffer_page_end(src_y, kWidth * kHeight + OFF); \ |
| align_buffer_page_end(src_u, kSizeUV + OFF); \ |
| align_buffer_page_end(src_v, kSizeUV + OFF); \ |
| align_buffer_page_end(dst_argb_b, kStrideB * kHeight + OFF); \ |
| for (int i = 0; i < kWidth * kHeight; ++i) { \ |
| src_y[i + OFF] = (fastrand() & 0xff); \ |
| } \ |
| for (int i = 0; i < kSizeUV; ++i) { \ |
| src_u[i + OFF] = (fastrand() & 0xff); \ |
| src_v[i + OFF] = (fastrand() & 0xff); \ |
| } \ |
| memset(dst_argb_b + OFF, 1, kStrideB * kHeight); \ |
| for (int i = 0; i < benchmark_iterations_; ++i) { \ |
| FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, \ |
| src_u + OFF, kStrideUV, \ |
| src_v + OFF, kStrideUV, \ |
| dst_argb_b + OFF, kStrideB, \ |
| kWidth, NEG kHeight); \ |
| } \ |
| /* Convert to a 3rd format in 1 step and 2 steps and compare */ \ |
| const int kStrideC = kWidth * BPP_C; \ |
| align_buffer_page_end(dst_argb_c, kStrideC * kHeight + OFF); \ |
| align_buffer_page_end(dst_argb_bc, kStrideC * kHeight + OFF); \ |
| memset(dst_argb_c + OFF, 2, kStrideC * kHeight); \ |
| memset(dst_argb_bc + OFF, 3, kStrideC * kHeight); \ |
| FMT_PLANAR##To##FMT_C(src_y + OFF, kWidth, \ |
| src_u + OFF, kStrideUV, \ |
| src_v + OFF, kStrideUV, \ |
| dst_argb_c + OFF, kStrideC, \ |
| kWidth, NEG kHeight); \ |
| /* Convert B to C */ \ |
| FMT_B##To##FMT_C(dst_argb_b + OFF, kStrideB, \ |
| dst_argb_bc + OFF, kStrideC, \ |
| kWidth, kHeight); \ |
| for (int i = 0; i < kStrideC * kHeight; ++i) { \ |
| EXPECT_EQ(dst_argb_c[i + OFF], dst_argb_bc[i + OFF]); \ |
| } \ |
| free_aligned_buffer_page_end(src_y); \ |
| free_aligned_buffer_page_end(src_u); \ |
| free_aligned_buffer_page_end(src_v); \ |
| free_aligned_buffer_page_end(dst_argb_b); \ |
| free_aligned_buffer_page_end(dst_argb_c); \ |
| free_aligned_buffer_page_end(dst_argb_bc); \ |
| } |
| |
| #define TESTPLANARTOE(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ |
| FMT_C, BPP_C) \ |
| TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ |
| benchmark_width_ - 4, _Any, +, 0, FMT_C, BPP_C) \ |
| TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ |
| benchmark_width_, _Unaligned, +, 1, FMT_C, BPP_C) \ |
| TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ |
| benchmark_width_, _Invert, -, 0, FMT_C, BPP_C) \ |
| TESTPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ |
| benchmark_width_, _Opt, +, 0, FMT_C, BPP_C) |
| |
| TESTPLANARTOE(I420, 2, 2, ARGB, 1, 4, ABGR, 4) |
| TESTPLANARTOE(J420, 2, 2, ARGB, 1, 4, ARGB, 4) |
| TESTPLANARTOE(J420, 2, 2, ABGR, 1, 4, ARGB, 4) |
| TESTPLANARTOE(H420, 2, 2, ARGB, 1, 4, ARGB, 4) |
| TESTPLANARTOE(H420, 2, 2, ABGR, 1, 4, ARGB, 4) |
| TESTPLANARTOE(I420, 2, 2, BGRA, 1, 4, ARGB, 4) |
| TESTPLANARTOE(I420, 2, 2, ABGR, 1, 4, ARGB, 4) |
| TESTPLANARTOE(I420, 2, 2, RGBA, 1, 4, ARGB, 4) |
| TESTPLANARTOE(I420, 2, 2, RGB24, 1, 3, ARGB, 4) |
| TESTPLANARTOE(I420, 2, 2, RAW, 1, 3, RGB24, 3) |
| TESTPLANARTOE(I420, 2, 2, RGB24, 1, 3, RAW, 3) |
| TESTPLANARTOE(I420, 2, 2, ARGB, 1, 4, RAW, 3) |
| TESTPLANARTOE(I420, 2, 2, RAW, 1, 3, ARGB, 4) |
| TESTPLANARTOE(I420, 2, 2, ARGB, 1, 4, RGB565, 2) |
| TESTPLANARTOE(I420, 2, 2, ARGB, 1, 4, ARGB1555, 2) |
| TESTPLANARTOE(I420, 2, 2, ARGB, 1, 4, ARGB4444, 2) |
| TESTPLANARTOE(I422, 2, 1, ARGB, 1, 4, ARGB, 4) |
| TESTPLANARTOE(J422, 2, 1, ARGB, 1, 4, ARGB, 4) |
| TESTPLANARTOE(J422, 2, 1, ABGR, 1, 4, ARGB, 4) |
| TESTPLANARTOE(H422, 2, 1, ARGB, 1, 4, ARGB, 4) |
| TESTPLANARTOE(H422, 2, 1, ABGR, 1, 4, ARGB, 4) |
| TESTPLANARTOE(I422, 2, 1, BGRA, 1, 4, ARGB, 4) |
| TESTPLANARTOE(I422, 2, 1, ABGR, 1, 4, ARGB, 4) |
| TESTPLANARTOE(I422, 2, 1, RGBA, 1, 4, ARGB, 4) |
| TESTPLANARTOE(I411, 4, 1, ARGB, 1, 4, ARGB, 4) |
| TESTPLANARTOE(I444, 1, 1, ARGB, 1, 4, ARGB, 4) |
| TESTPLANARTOE(J444, 1, 1, ARGB, 1, 4, ARGB, 4) |
| TESTPLANARTOE(I444, 1, 1, ABGR, 1, 4, ARGB, 4) |
| TESTPLANARTOE(I420, 2, 2, YUY2, 2, 4, ARGB, 4) |
| TESTPLANARTOE(I420, 2, 2, UYVY, 2, 4, ARGB, 4) |
| TESTPLANARTOE(I422, 2, 1, YUY2, 2, 4, ARGB, 4) |
| TESTPLANARTOE(I422, 2, 1, UYVY, 2, 4, ARGB, 4) |
| |
| #define TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ |
| W1280, N, NEG, OFF, FMT_C, BPP_C, ATTEN) \ |
| TEST_F(LibYUVConvertTest, FMT_PLANAR##To##FMT_B##_##FMT_C##N) { \ |
| const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ |
| const int kHeight = benchmark_height_; \ |
| const int kStrideB = SUBSAMPLE(kWidth, SUB_B) * BPP_B; \ |
| const int kSizeUV = \ |
| SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y); \ |
| align_buffer_page_end(src_y, kWidth * kHeight + OFF); \ |
| align_buffer_page_end(src_u, kSizeUV + OFF); \ |
| align_buffer_page_end(src_v, kSizeUV + OFF); \ |
| align_buffer_page_end(src_a, kWidth * kHeight + OFF); \ |
| align_buffer_page_end(dst_argb_b, kStrideB * kHeight + OFF); \ |
| for (int i = 0; i < kWidth * kHeight; ++i) { \ |
| src_y[i + OFF] = (fastrand() & 0xff); \ |
| src_a[i + OFF] = (fastrand() & 0xff); \ |
| } \ |
| for (int i = 0; i < kSizeUV; ++i) { \ |
| src_u[i + OFF] = (fastrand() & 0xff); \ |
| src_v[i + OFF] = (fastrand() & 0xff); \ |
| } \ |
| memset(dst_argb_b + OFF, 1, kStrideB * kHeight); \ |
| for (int i = 0; i < benchmark_iterations_; ++i) { \ |
| FMT_PLANAR##To##FMT_B(src_y + OFF, kWidth, \ |
| src_u + OFF, SUBSAMPLE(kWidth, SUBSAMP_X), \ |
| src_v + OFF, SUBSAMPLE(kWidth, SUBSAMP_X), \ |
| src_a + OFF, kWidth, \ |
| dst_argb_b + OFF, kStrideB, \ |
| kWidth, NEG kHeight, ATTEN); \ |
| } \ |
| int max_diff = 0; \ |
| /* Convert to a 3rd format in 1 step and 2 steps and compare */ \ |
| const int kStrideC = kWidth * BPP_C; \ |
| align_buffer_page_end(dst_argb_c, kStrideC * kHeight + OFF); \ |
| align_buffer_page_end(dst_argb_bc, kStrideC * kHeight + OFF); \ |
| memset(dst_argb_c + OFF, 2, kStrideC * kHeight); \ |
| memset(dst_argb_bc + OFF, 3, kStrideC * kHeight); \ |
| FMT_PLANAR##To##FMT_C(src_y + OFF, kWidth, \ |
| src_u + OFF, SUBSAMPLE(kWidth, SUBSAMP_X), \ |
| src_v + OFF, SUBSAMPLE(kWidth, SUBSAMP_X), \ |
| src_a + OFF, kWidth, \ |
| dst_argb_c + OFF, kStrideC, \ |
| kWidth, NEG kHeight, ATTEN); \ |
| /* Convert B to C */ \ |
| FMT_B##To##FMT_C(dst_argb_b + OFF, kStrideB, \ |
| dst_argb_bc + OFF, kStrideC, \ |
| kWidth, kHeight); \ |
| for (int i = 0; i < kStrideC * kHeight; ++i) { \ |
| EXPECT_EQ(dst_argb_c[i + OFF], dst_argb_bc[i + OFF]); \ |
| } \ |
| free_aligned_buffer_page_end(src_y); \ |
| free_aligned_buffer_page_end(src_u); \ |
| free_aligned_buffer_page_end(src_v); \ |
| free_aligned_buffer_page_end(src_a); \ |
| free_aligned_buffer_page_end(dst_argb_b); \ |
| free_aligned_buffer_page_end(dst_argb_c); \ |
| free_aligned_buffer_page_end(dst_argb_bc); \ |
| } |
| |
| #define TESTQPLANARTOE(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ |
| FMT_C, BPP_C) \ |
| TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ |
| benchmark_width_ - 4, _Any, +, 0, FMT_C, BPP_C, 0) \ |
| TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ |
| benchmark_width_, _Unaligned, +, 1, FMT_C, BPP_C, 0) \ |
| TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ |
| benchmark_width_, _Invert, -, 0, FMT_C, BPP_C, 0) \ |
| TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ |
| benchmark_width_, _Opt, +, 0, FMT_C, BPP_C, 0) \ |
| TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ |
| benchmark_width_, _Premult, +, 0, FMT_C, BPP_C, 1) |
| |
| TESTQPLANARTOE(I420Alpha, 2, 2, ARGB, 1, 4, ABGR, 4) |
| TESTQPLANARTOE(I420Alpha, 2, 2, ABGR, 1, 4, ARGB, 4) |
| |
| } // namespace libyuv |