OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2011 The LibYuv Project Authors. All rights reserved. | 2 * Copyright 2011 The LibYuv Project Authors. All rights reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 4 * Use of this source code is governed by a BSD-style license |
5 * that can be found in the LICENSE file in the root of the source | 5 * that can be found in the LICENSE file in the root of the source |
6 * tree. An additional intellectual property rights grant can be found | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
(...skipping 12 matching lines...) Expand all Loading... |
23 #endif | 23 #endif |
24 #include "../unit_test/unit_test.h" | 24 #include "../unit_test/unit_test.h" |
25 #include "libyuv/planar_functions.h" | 25 #include "libyuv/planar_functions.h" |
26 #include "libyuv/rotate.h" | 26 #include "libyuv/rotate.h" |
27 #include "libyuv/video_common.h" | 27 #include "libyuv/video_common.h" |
28 | 28 |
29 namespace libyuv { | 29 namespace libyuv { |
30 | 30 |
31 #define SUBSAMPLE(v, a) ((((v) + (a)-1)) / (a)) | 31 #define SUBSAMPLE(v, a) ((((v) + (a)-1)) / (a)) |
32 | 32 |
33 #define TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ | 33 #define TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
34 FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, W1280, N, NEG, OFF) \ | 34 FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, W1280, N, NEG, OFF) \ |
35 TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) { \ | 35 TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) { \ |
36 const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ | 36 const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ |
37 const int kHeight = benchmark_height_; \ | 37 const int kHeight = benchmark_height_; \ |
38 align_buffer_page_end(src_y, kWidth* kHeight + OFF); \ | 38 align_buffer_page_end(src_y, kWidth* kHeight + OFF); \ |
39 align_buffer_page_end(src_u, SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ | 39 align_buffer_page_end( \ |
40 SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + \ | 40 src_u, \ |
41 OFF); \ | 41 SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + \ |
42 align_buffer_page_end(src_v, SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ | 42 OFF); \ |
43 SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + \ | 43 align_buffer_page_end( \ |
44 OFF); \ | 44 src_v, \ |
45 align_buffer_page_end(dst_y_c, kWidth* kHeight); \ | 45 SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + \ |
46 align_buffer_page_end(dst_u_c, SUBSAMPLE(kWidth, SUBSAMP_X) * \ | 46 OFF); \ |
47 SUBSAMPLE(kHeight, SUBSAMP_Y)); \ | 47 align_buffer_page_end(dst_y_c, kWidth* kHeight); \ |
48 align_buffer_page_end(dst_v_c, SUBSAMPLE(kWidth, SUBSAMP_X) * \ | 48 align_buffer_page_end( \ |
49 SUBSAMPLE(kHeight, SUBSAMP_Y)); \ | 49 dst_u_c, \ |
50 align_buffer_page_end(dst_y_opt, kWidth* kHeight); \ | 50 SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
51 align_buffer_page_end(dst_u_opt, SUBSAMPLE(kWidth, SUBSAMP_X) * \ | 51 align_buffer_page_end( \ |
52 SUBSAMPLE(kHeight, SUBSAMP_Y)); \ | 52 dst_v_c, \ |
53 align_buffer_page_end(dst_v_opt, SUBSAMPLE(kWidth, SUBSAMP_X) * \ | 53 SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
54 SUBSAMPLE(kHeight, SUBSAMP_Y)); \ | 54 align_buffer_page_end(dst_y_opt, kWidth* kHeight); \ |
55 for (int i = 0; i < kHeight; ++i) \ | 55 align_buffer_page_end( \ |
56 for (int j = 0; j < kWidth; ++j) \ | 56 dst_u_opt, \ |
57 src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ | 57 SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
58 for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ | 58 align_buffer_page_end( \ |
59 for (int j = 0; j < SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ | 59 dst_v_opt, \ |
60 src_u[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ | 60 SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
61 (fastrand() & 0xff); \ | 61 for (int i = 0; i < kHeight; ++i) \ |
62 src_v[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ | 62 for (int j = 0; j < kWidth; ++j) \ |
63 (fastrand() & 0xff); \ | 63 src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ |
64 } \ | 64 for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ |
65 } \ | 65 for (int j = 0; j < SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ |
66 memset(dst_y_c, 1, kWidth* kHeight); \ | 66 src_u[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ |
67 memset(dst_u_c, 2, \ | 67 (fastrand() & 0xff); \ |
68 SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ | 68 src_v[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ |
69 memset(dst_v_c, 3, \ | 69 (fastrand() & 0xff); \ |
70 SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ | 70 } \ |
71 memset(dst_y_opt, 101, kWidth* kHeight); \ | 71 } \ |
72 memset(dst_u_opt, 102, \ | 72 memset(dst_y_c, 1, kWidth* kHeight); \ |
73 SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ | 73 memset(dst_u_c, 2, \ |
74 memset(dst_v_opt, 103, \ | 74 SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
75 SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ | 75 memset(dst_v_c, 3, \ |
76 MaskCpuFlags(disable_cpu_flags_); \ | 76 SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
77 SRC_FMT_PLANAR##To##FMT_PLANAR( \ | 77 memset(dst_y_opt, 101, kWidth* kHeight); \ |
78 src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ | 78 memset(dst_u_opt, 102, \ |
79 src_v + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), dst_y_c, kWidth, \ | 79 SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
80 dst_u_c, SUBSAMPLE(kWidth, SUBSAMP_X), dst_v_c, \ | 80 memset(dst_v_opt, 103, \ |
81 SUBSAMPLE(kWidth, SUBSAMP_X), kWidth, NEG kHeight); \ | 81 SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
82 MaskCpuFlags(benchmark_cpu_info_); \ | 82 MaskCpuFlags(disable_cpu_flags_); \ |
83 for (int i = 0; i < benchmark_iterations_; ++i) { \ | 83 SRC_FMT_PLANAR##To##FMT_PLANAR( \ |
84 SRC_FMT_PLANAR##To##FMT_PLANAR( \ | 84 src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ |
85 src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ | 85 src_v + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), dst_y_c, kWidth, \ |
86 src_v + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), dst_y_opt, kWidth, \ | 86 dst_u_c, SUBSAMPLE(kWidth, SUBSAMP_X), dst_v_c, \ |
87 dst_u_opt, SUBSAMPLE(kWidth, SUBSAMP_X), dst_v_opt, \ | 87 SUBSAMPLE(kWidth, SUBSAMP_X), kWidth, NEG kHeight); \ |
88 SUBSAMPLE(kWidth, SUBSAMP_X), kWidth, NEG kHeight); \ | 88 MaskCpuFlags(benchmark_cpu_info_); \ |
89 } \ | 89 for (int i = 0; i < benchmark_iterations_; ++i) { \ |
90 int max_diff = 0; \ | 90 SRC_FMT_PLANAR##To##FMT_PLANAR( \ |
91 for (int i = 0; i < kHeight; ++i) { \ | 91 src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ |
92 for (int j = 0; j < kWidth; ++j) { \ | 92 src_v + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), dst_y_opt, kWidth, \ |
93 int abs_diff = abs(static_cast<int>(dst_y_c[i * kWidth + j]) - \ | 93 dst_u_opt, SUBSAMPLE(kWidth, SUBSAMP_X), dst_v_opt, \ |
94 static_cast<int>(dst_y_opt[i * kWidth + j])); \ | 94 SUBSAMPLE(kWidth, SUBSAMP_X), kWidth, NEG kHeight); \ |
95 if (abs_diff > max_diff) { \ | 95 } \ |
96 max_diff = abs_diff; \ | 96 int max_diff = 0; \ |
97 } \ | 97 for (int i = 0; i < kHeight; ++i) { \ |
98 } \ | 98 for (int j = 0; j < kWidth; ++j) { \ |
99 } \ | 99 int abs_diff = abs(static_cast<int>(dst_y_c[i * kWidth + j]) - \ |
100 EXPECT_EQ(0, max_diff); \ | 100 static_cast<int>(dst_y_opt[i * kWidth + j])); \ |
101 for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ | 101 if (abs_diff > max_diff) { \ |
102 for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) { \ | 102 max_diff = abs_diff; \ |
103 int abs_diff = abs( \ | 103 } \ |
104 static_cast<int>(dst_u_c[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j]) - \ | 104 } \ |
105 static_cast<int>( \ | 105 } \ |
106 dst_u_opt[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j])); \ | 106 EXPECT_EQ(0, max_diff); \ |
107 if (abs_diff > max_diff) { \ | 107 for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ |
108 max_diff = abs_diff; \ | 108 for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) { \ |
109 } \ | 109 int abs_diff = abs( \ |
110 } \ | 110 static_cast<int>(dst_u_c[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j]) - \ |
111 } \ | 111 static_cast<int>( \ |
112 EXPECT_LE(max_diff, 3); \ | 112 dst_u_opt[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j])); \ |
113 for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ | 113 if (abs_diff > max_diff) { \ |
114 for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) { \ | 114 max_diff = abs_diff; \ |
115 int abs_diff = abs( \ | 115 } \ |
116 static_cast<int>(dst_v_c[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j]) - \ | 116 } \ |
117 static_cast<int>( \ | 117 } \ |
118 dst_v_opt[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j])); \ | 118 EXPECT_LE(max_diff, 3); \ |
119 if (abs_diff > max_diff) { \ | 119 for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ |
120 max_diff = abs_diff; \ | 120 for (int j = 0; j < SUBSAMPLE(kWidth, SUBSAMP_X); ++j) { \ |
121 } \ | 121 int abs_diff = abs( \ |
122 } \ | 122 static_cast<int>(dst_v_c[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j]) - \ |
123 } \ | 123 static_cast<int>( \ |
124 EXPECT_LE(max_diff, 3); \ | 124 dst_v_opt[i * SUBSAMPLE(kWidth, SUBSAMP_X) + j])); \ |
125 free_aligned_buffer_page_end(dst_y_c); \ | 125 if (abs_diff > max_diff) { \ |
126 free_aligned_buffer_page_end(dst_u_c); \ | 126 max_diff = abs_diff; \ |
127 free_aligned_buffer_page_end(dst_v_c); \ | 127 } \ |
128 free_aligned_buffer_page_end(dst_y_opt); \ | 128 } \ |
129 free_aligned_buffer_page_end(dst_u_opt); \ | 129 } \ |
130 free_aligned_buffer_page_end(dst_v_opt); \ | 130 EXPECT_LE(max_diff, 3); \ |
131 free_aligned_buffer_page_end(src_y); \ | 131 free_aligned_buffer_page_end(dst_y_c); \ |
132 free_aligned_buffer_page_end(src_u); \ | 132 free_aligned_buffer_page_end(dst_u_c); \ |
133 free_aligned_buffer_page_end(src_v); \ | 133 free_aligned_buffer_page_end(dst_v_c); \ |
| 134 free_aligned_buffer_page_end(dst_y_opt); \ |
| 135 free_aligned_buffer_page_end(dst_u_opt); \ |
| 136 free_aligned_buffer_page_end(dst_v_opt); \ |
| 137 free_aligned_buffer_page_end(src_y); \ |
| 138 free_aligned_buffer_page_end(src_u); \ |
| 139 free_aligned_buffer_page_end(src_v); \ |
134 } | 140 } |
135 | 141 |
136 #define TESTPLANARTOP(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ | 142 #define TESTPLANARTOP(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
137 FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y) \ | 143 FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y) \ |
138 TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ | 144 TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ |
139 SUBSAMP_X, SUBSAMP_Y, benchmark_width_ - 4, _Any, +, 0) \ | 145 SUBSAMP_X, SUBSAMP_Y, benchmark_width_ - 4, _Any, +, 0) \ |
140 TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ | 146 TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ |
141 SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Unaligned, +, 1) \ | 147 SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Unaligned, +, 1) \ |
142 TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ | 148 TESTPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ |
143 SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Invert, -, 0) \ | 149 SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Invert, -, 0) \ |
(...skipping 15 matching lines...) Expand all Loading... |
159 W1280, N, NEG, OFF, PN, OFF_U, OFF_V) \ | 165 W1280, N, NEG, OFF, PN, OFF_U, OFF_V) \ |
160 TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##_##PN##N) { \ | 166 TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##_##PN##N) { \ |
161 const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ | 167 const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ |
162 const int kHeight = benchmark_height_; \ | 168 const int kHeight = benchmark_height_; \ |
163 const int kSizeUV = \ | 169 const int kSizeUV = \ |
164 SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); \ | 170 SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); \ |
165 align_buffer_page_end(src_y, kWidth* kHeight + OFF); \ | 171 align_buffer_page_end(src_y, kWidth* kHeight + OFF); \ |
166 align_buffer_page_end(src_uv, \ | 172 align_buffer_page_end(src_uv, \ |
167 kSizeUV*((PIXEL_STRIDE == 3) ? 3 : 2) + OFF); \ | 173 kSizeUV*((PIXEL_STRIDE == 3) ? 3 : 2) + OFF); \ |
168 align_buffer_page_end(dst_y_c, kWidth* kHeight); \ | 174 align_buffer_page_end(dst_y_c, kWidth* kHeight); \ |
169 align_buffer_page_end(dst_u_c, SUBSAMPLE(kWidth, SUBSAMP_X) * \ | 175 align_buffer_page_end( \ |
170 SUBSAMPLE(kHeight, SUBSAMP_Y)); \ | 176 dst_u_c, \ |
171 align_buffer_page_end(dst_v_c, SUBSAMPLE(kWidth, SUBSAMP_X) * \ | 177 SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
172 SUBSAMPLE(kHeight, SUBSAMP_Y)); \ | 178 align_buffer_page_end( \ |
| 179 dst_v_c, \ |
| 180 SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
173 align_buffer_page_end(dst_y_opt, kWidth* kHeight); \ | 181 align_buffer_page_end(dst_y_opt, kWidth* kHeight); \ |
174 align_buffer_page_end(dst_u_opt, SUBSAMPLE(kWidth, SUBSAMP_X) * \ | 182 align_buffer_page_end( \ |
175 SUBSAMPLE(kHeight, SUBSAMP_Y)); \ | 183 dst_u_opt, \ |
176 align_buffer_page_end(dst_v_opt, SUBSAMPLE(kWidth, SUBSAMP_X) * \ | 184 SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
177 SUBSAMPLE(kHeight, SUBSAMP_Y)); \ | 185 align_buffer_page_end( \ |
| 186 dst_v_opt, \ |
| 187 SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
178 uint8* src_u = src_uv + OFF_U; \ | 188 uint8* src_u = src_uv + OFF_U; \ |
179 uint8* src_v = src_uv + (PIXEL_STRIDE == 1 ? kSizeUV : OFF_V); \ | 189 uint8* src_v = src_uv + (PIXEL_STRIDE == 1 ? kSizeUV : OFF_V); \ |
180 int src_stride_uv = SUBSAMPLE(kWidth, SUBSAMP_X) * PIXEL_STRIDE; \ | 190 int src_stride_uv = SUBSAMPLE(kWidth, SUBSAMP_X) * PIXEL_STRIDE; \ |
181 for (int i = 0; i < kHeight; ++i) \ | 191 for (int i = 0; i < kHeight; ++i) \ |
182 for (int j = 0; j < kWidth; ++j) \ | 192 for (int j = 0; j < kWidth; ++j) \ |
183 src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ | 193 src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ |
184 for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ | 194 for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ |
185 for (int j = 0; j < SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ | 195 for (int j = 0; j < SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ |
186 src_u[(i * src_stride_uv) + j * PIXEL_STRIDE + OFF] = \ | 196 src_u[(i * src_stride_uv) + j * PIXEL_STRIDE + OFF] = \ |
187 (fastrand() & 0xff); \ | 197 (fastrand() & 0xff); \ |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
271 FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Invert, \ | 281 FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Invert, \ |
272 -, 0, PN, OFF_U, OFF_V) \ | 282 -, 0, PN, OFF_U, OFF_V) \ |
273 TESTAPLANARTOPI(SRC_FMT_PLANAR, PIXEL_STRIDE, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ | 283 TESTAPLANARTOPI(SRC_FMT_PLANAR, PIXEL_STRIDE, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
274 FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Opt, +, \ | 284 FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Opt, +, \ |
275 0, PN, OFF_U, OFF_V) | 285 0, PN, OFF_U, OFF_V) |
276 | 286 |
277 TESTAPLANARTOP(Android420, I420, 1, 0, 0, 2, 2, I420, 2, 2) | 287 TESTAPLANARTOP(Android420, I420, 1, 0, 0, 2, 2, I420, 2, 2) |
278 TESTAPLANARTOP(Android420, NV12, 2, 0, 1, 2, 2, I420, 2, 2) | 288 TESTAPLANARTOP(Android420, NV12, 2, 0, 1, 2, 2, I420, 2, 2) |
279 TESTAPLANARTOP(Android420, NV21, 2, 1, 0, 2, 2, I420, 2, 2) | 289 TESTAPLANARTOP(Android420, NV21, 2, 1, 0, 2, 2, I420, 2, 2) |
280 | 290 |
281 #define TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ | 291 #define TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
282 FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, W1280, N, NEG, OFF) \ | 292 FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, W1280, N, NEG, OFF) \ |
283 TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) { \ | 293 TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) { \ |
284 const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ | 294 const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ |
285 const int kHeight = benchmark_height_; \ | 295 const int kHeight = benchmark_height_; \ |
286 align_buffer_page_end(src_y, kWidth* kHeight + OFF); \ | 296 align_buffer_page_end(src_y, kWidth* kHeight + OFF); \ |
287 align_buffer_page_end(src_u, SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ | 297 align_buffer_page_end( \ |
288 SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + \ | 298 src_u, \ |
289 OFF); \ | 299 SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + \ |
290 align_buffer_page_end(src_v, SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ | 300 OFF); \ |
291 SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + \ | 301 align_buffer_page_end( \ |
292 OFF); \ | 302 src_v, \ |
293 align_buffer_page_end(dst_y_c, kWidth* kHeight); \ | 303 SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + \ |
294 align_buffer_page_end(dst_uv_c, SUBSAMPLE(kWidth * 2, SUBSAMP_X) * \ | 304 OFF); \ |
295 SUBSAMPLE(kHeight, SUBSAMP_Y)); \ | 305 align_buffer_page_end(dst_y_c, kWidth* kHeight); \ |
296 align_buffer_page_end(dst_y_opt, kWidth* kHeight); \ | 306 align_buffer_page_end( \ |
297 align_buffer_page_end(dst_uv_opt, SUBSAMPLE(kWidth * 2, SUBSAMP_X) * \ | 307 dst_uv_c, \ |
298 SUBSAMPLE(kHeight, SUBSAMP_Y)); \ | 308 SUBSAMPLE(kWidth * 2, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
299 for (int i = 0; i < kHeight; ++i) \ | 309 align_buffer_page_end(dst_y_opt, kWidth* kHeight); \ |
300 for (int j = 0; j < kWidth; ++j) \ | 310 align_buffer_page_end( \ |
301 src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ | 311 dst_uv_opt, \ |
302 for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ | 312 SUBSAMPLE(kWidth * 2, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
303 for (int j = 0; j < SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ | 313 for (int i = 0; i < kHeight; ++i) \ |
304 src_u[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ | 314 for (int j = 0; j < kWidth; ++j) \ |
305 (fastrand() & 0xff); \ | 315 src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ |
306 src_v[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ | 316 for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ |
307 (fastrand() & 0xff); \ | 317 for (int j = 0; j < SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ |
308 } \ | 318 src_u[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ |
309 } \ | 319 (fastrand() & 0xff); \ |
310 memset(dst_y_c, 1, kWidth* kHeight); \ | 320 src_v[(i * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ |
311 memset(dst_uv_c, 2, \ | 321 (fastrand() & 0xff); \ |
312 SUBSAMPLE(kWidth * 2, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ | 322 } \ |
313 memset(dst_y_opt, 101, kWidth* kHeight); \ | 323 } \ |
314 memset(dst_uv_opt, 102, \ | 324 memset(dst_y_c, 1, kWidth* kHeight); \ |
315 SUBSAMPLE(kWidth * 2, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ | 325 memset(dst_uv_c, 2, \ |
316 MaskCpuFlags(disable_cpu_flags_); \ | 326 SUBSAMPLE(kWidth * 2, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
317 SRC_FMT_PLANAR##To##FMT_PLANAR( \ | 327 memset(dst_y_opt, 101, kWidth* kHeight); \ |
318 src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ | 328 memset(dst_uv_opt, 102, \ |
319 src_v + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), dst_y_c, kWidth, \ | 329 SUBSAMPLE(kWidth * 2, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
320 dst_uv_c, SUBSAMPLE(kWidth * 2, SUBSAMP_X), kWidth, NEG kHeight); \ | 330 MaskCpuFlags(disable_cpu_flags_); \ |
321 MaskCpuFlags(benchmark_cpu_info_); \ | 331 SRC_FMT_PLANAR##To##FMT_PLANAR( \ |
322 for (int i = 0; i < benchmark_iterations_; ++i) { \ | 332 src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ |
323 SRC_FMT_PLANAR##To##FMT_PLANAR( \ | 333 src_v + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), dst_y_c, kWidth, \ |
324 src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ | 334 dst_uv_c, SUBSAMPLE(kWidth * 2, SUBSAMP_X), kWidth, NEG kHeight); \ |
325 src_v + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), dst_y_opt, kWidth, \ | 335 MaskCpuFlags(benchmark_cpu_info_); \ |
326 dst_uv_opt, SUBSAMPLE(kWidth * 2, SUBSAMP_X), kWidth, NEG kHeight); \ | 336 for (int i = 0; i < benchmark_iterations_; ++i) { \ |
327 } \ | 337 SRC_FMT_PLANAR##To##FMT_PLANAR( \ |
328 int max_diff = 0; \ | 338 src_y + OFF, kWidth, src_u + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), \ |
329 for (int i = 0; i < kHeight; ++i) { \ | 339 src_v + OFF, SUBSAMPLE(kWidth, SRC_SUBSAMP_X), dst_y_opt, kWidth, \ |
330 for (int j = 0; j < kWidth; ++j) { \ | 340 dst_uv_opt, SUBSAMPLE(kWidth * 2, SUBSAMP_X), kWidth, NEG kHeight); \ |
331 int abs_diff = abs(static_cast<int>(dst_y_c[i * kWidth + j]) - \ | 341 } \ |
332 static_cast<int>(dst_y_opt[i * kWidth + j])); \ | 342 int max_diff = 0; \ |
333 if (abs_diff > max_diff) { \ | 343 for (int i = 0; i < kHeight; ++i) { \ |
334 max_diff = abs_diff; \ | 344 for (int j = 0; j < kWidth; ++j) { \ |
335 } \ | 345 int abs_diff = abs(static_cast<int>(dst_y_c[i * kWidth + j]) - \ |
336 } \ | 346 static_cast<int>(dst_y_opt[i * kWidth + j])); \ |
337 } \ | 347 if (abs_diff > max_diff) { \ |
338 EXPECT_LE(max_diff, 1); \ | 348 max_diff = abs_diff; \ |
339 for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ | 349 } \ |
340 for (int j = 0; j < SUBSAMPLE(kWidth * 2, SUBSAMP_X); ++j) { \ | 350 } \ |
341 int abs_diff = \ | 351 } \ |
342 abs(static_cast<int>( \ | 352 EXPECT_LE(max_diff, 1); \ |
343 dst_uv_c[i * SUBSAMPLE(kWidth * 2, SUBSAMP_X) + j]) - \ | 353 for (int i = 0; i < SUBSAMPLE(kHeight, SUBSAMP_Y); ++i) { \ |
344 static_cast<int>( \ | 354 for (int j = 0; j < SUBSAMPLE(kWidth * 2, SUBSAMP_X); ++j) { \ |
345 dst_uv_opt[i * SUBSAMPLE(kWidth * 2, SUBSAMP_X) + j])); \ | 355 int abs_diff = \ |
346 if (abs_diff > max_diff) { \ | 356 abs(static_cast<int>( \ |
347 max_diff = abs_diff; \ | 357 dst_uv_c[i * SUBSAMPLE(kWidth * 2, SUBSAMP_X) + j]) - \ |
348 } \ | 358 static_cast<int>( \ |
349 } \ | 359 dst_uv_opt[i * SUBSAMPLE(kWidth * 2, SUBSAMP_X) + j])); \ |
350 } \ | 360 if (abs_diff > max_diff) { \ |
351 EXPECT_LE(max_diff, 1); \ | 361 max_diff = abs_diff; \ |
352 free_aligned_buffer_page_end(dst_y_c); \ | 362 } \ |
353 free_aligned_buffer_page_end(dst_uv_c); \ | 363 } \ |
354 free_aligned_buffer_page_end(dst_y_opt); \ | 364 } \ |
355 free_aligned_buffer_page_end(dst_uv_opt); \ | 365 EXPECT_LE(max_diff, 1); \ |
356 free_aligned_buffer_page_end(src_y); \ | 366 free_aligned_buffer_page_end(dst_y_c); \ |
357 free_aligned_buffer_page_end(src_u); \ | 367 free_aligned_buffer_page_end(dst_uv_c); \ |
358 free_aligned_buffer_page_end(src_v); \ | 368 free_aligned_buffer_page_end(dst_y_opt); \ |
| 369 free_aligned_buffer_page_end(dst_uv_opt); \ |
| 370 free_aligned_buffer_page_end(src_y); \ |
| 371 free_aligned_buffer_page_end(src_u); \ |
| 372 free_aligned_buffer_page_end(src_v); \ |
359 } | 373 } |
360 | 374 |
361 #define TESTPLANARTOBP(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ | 375 #define TESTPLANARTOBP(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
362 FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y) \ | 376 FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y) \ |
363 TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ | 377 TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ |
364 SUBSAMP_X, SUBSAMP_Y, benchmark_width_ - 4, _Any, +, 0) \ | 378 SUBSAMP_X, SUBSAMP_Y, benchmark_width_ - 4, _Any, +, 0) \ |
365 TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ | 379 TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ |
366 SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Unaligned, +, 1) \ | 380 SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Unaligned, +, 1) \ |
367 TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ | 381 TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ |
368 SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Invert, -, 0) \ | 382 SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Invert, -, 0) \ |
369 TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ | 383 TESTPLANARTOBPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, FMT_PLANAR, \ |
370 SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Opt, +, 0) | 384 SUBSAMP_X, SUBSAMP_Y, benchmark_width_, _Opt, +, 0) |
371 | 385 |
372 TESTPLANARTOBP(I420, 2, 2, NV12, 2, 2) | 386 TESTPLANARTOBP(I420, 2, 2, NV12, 2, 2) |
373 TESTPLANARTOBP(I420, 2, 2, NV21, 2, 2) | 387 TESTPLANARTOBP(I420, 2, 2, NV21, 2, 2) |
374 | 388 |
375 #define TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ | 389 #define TESTBIPLANARTOPI(SRC_FMT_PLANAR, SRC_SUBSAMP_X, SRC_SUBSAMP_Y, \ |
376 FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, W1280, N, NEG, OFF, \ | 390 FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, W1280, N, NEG, OFF, \ |
377 DOY) \ | 391 DOY) \ |
378 TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) { \ | 392 TEST_F(LibYUVConvertTest, SRC_FMT_PLANAR##To##FMT_PLANAR##N) { \ |
379 const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ | 393 const int kWidth = ((W1280) > 0) ? (W1280) : 1; \ |
380 const int kHeight = benchmark_height_; \ | 394 const int kHeight = benchmark_height_; \ |
381 align_buffer_page_end(src_y, kWidth* kHeight + OFF); \ | 395 align_buffer_page_end(src_y, kWidth* kHeight + OFF); \ |
382 align_buffer_page_end(src_uv, 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ | 396 align_buffer_page_end(src_uv, \ |
383 SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + \ | 397 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X) * \ |
384 OFF); \ | 398 SUBSAMPLE(kHeight, SRC_SUBSAMP_Y) + \ |
| 399 OFF); \ |
385 align_buffer_page_end(dst_y_c, kWidth* kHeight); \ | 400 align_buffer_page_end(dst_y_c, kWidth* kHeight); \ |
386 align_buffer_page_end(dst_u_c, SUBSAMPLE(kWidth, SUBSAMP_X) * \ | 401 align_buffer_page_end( \ |
387 SUBSAMPLE(kHeight, SUBSAMP_Y)); \ | 402 dst_u_c, \ |
388 align_buffer_page_end(dst_v_c, SUBSAMPLE(kWidth, SUBSAMP_X) * \ | 403 SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
389 SUBSAMPLE(kHeight, SUBSAMP_Y)); \ | 404 align_buffer_page_end( \ |
| 405 dst_v_c, \ |
| 406 SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
390 align_buffer_page_end(dst_y_opt, kWidth* kHeight); \ | 407 align_buffer_page_end(dst_y_opt, kWidth* kHeight); \ |
391 align_buffer_page_end(dst_u_opt, SUBSAMPLE(kWidth, SUBSAMP_X) * \ | 408 align_buffer_page_end( \ |
392 SUBSAMPLE(kHeight, SUBSAMP_Y)); \ | 409 dst_u_opt, \ |
393 align_buffer_page_end(dst_v_opt, SUBSAMPLE(kWidth, SUBSAMP_X) * \ | 410 SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
394 SUBSAMPLE(kHeight, SUBSAMP_Y)); \ | 411 align_buffer_page_end( \ |
| 412 dst_v_opt, \ |
| 413 SUBSAMPLE(kWidth, SUBSAMP_X) * SUBSAMPLE(kHeight, SUBSAMP_Y)); \ |
395 for (int i = 0; i < kHeight; ++i) \ | 414 for (int i = 0; i < kHeight; ++i) \ |
396 for (int j = 0; j < kWidth; ++j) \ | 415 for (int j = 0; j < kWidth; ++j) \ |
397 src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ | 416 src_y[i * kWidth + j + OFF] = (fastrand() & 0xff); \ |
398 for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ | 417 for (int i = 0; i < SUBSAMPLE(kHeight, SRC_SUBSAMP_Y); ++i) { \ |
399 for (int j = 0; j < 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ | 418 for (int j = 0; j < 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X); ++j) { \ |
400 src_uv[(i * 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ | 419 src_uv[(i * 2 * SUBSAMPLE(kWidth, SRC_SUBSAMP_X)) + j + OFF] = \ |
401 (fastrand() & 0xff); \ | 420 (fastrand() & 0xff); \ |
402 } \ | 421 } \ |
403 } \ | 422 } \ |
404 memset(dst_y_c, 1, kWidth* kHeight); \ | 423 memset(dst_y_c, 1, kWidth* kHeight); \ |
(...skipping 957 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1362 | 1381 |
1363 TEST_F(LibYUVConvertTest, MJPGToI420) { | 1382 TEST_F(LibYUVConvertTest, MJPGToI420) { |
1364 const int kOff = 10; | 1383 const int kOff = 10; |
1365 const int kMinJpeg = 64; | 1384 const int kMinJpeg = 64; |
1366 const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg | 1385 const int kImageSize = benchmark_width_ * benchmark_height_ >= kMinJpeg |
1367 ? benchmark_width_ * benchmark_height_ | 1386 ? benchmark_width_ * benchmark_height_ |
1368 : kMinJpeg; | 1387 : kMinJpeg; |
1369 const int kSize = kImageSize + kOff; | 1388 const int kSize = kImageSize + kOff; |
1370 align_buffer_page_end(orig_pixels, kSize); | 1389 align_buffer_page_end(orig_pixels, kSize); |
1371 align_buffer_page_end(dst_y_opt, benchmark_width_ * benchmark_height_); | 1390 align_buffer_page_end(dst_y_opt, benchmark_width_ * benchmark_height_); |
1372 align_buffer_page_end(dst_u_opt, SUBSAMPLE(benchmark_width_, 2) * | 1391 align_buffer_page_end( |
1373 SUBSAMPLE(benchmark_height_, 2)); | 1392 dst_u_opt, |
1374 align_buffer_page_end(dst_v_opt, SUBSAMPLE(benchmark_width_, 2) * | 1393 SUBSAMPLE(benchmark_width_, 2) * SUBSAMPLE(benchmark_height_, 2)); |
1375 SUBSAMPLE(benchmark_height_, 2)); | 1394 align_buffer_page_end( |
| 1395 dst_v_opt, |
| 1396 SUBSAMPLE(benchmark_width_, 2) * SUBSAMPLE(benchmark_height_, 2)); |
1376 | 1397 |
1377 // EOI, SOI to make MJPG appear valid. | 1398 // EOI, SOI to make MJPG appear valid. |
1378 memset(orig_pixels, 0, kSize); | 1399 memset(orig_pixels, 0, kSize); |
1379 orig_pixels[0] = 0xff; | 1400 orig_pixels[0] = 0xff; |
1380 orig_pixels[1] = 0xd8; // SOI. | 1401 orig_pixels[1] = 0xd8; // SOI. |
1381 orig_pixels[kSize - kOff + 0] = 0xff; | 1402 orig_pixels[kSize - kOff + 0] = 0xff; |
1382 orig_pixels[kSize - kOff + 1] = 0xd9; // EOI. | 1403 orig_pixels[kSize - kOff + 1] = 0xd9; // EOI. |
1383 | 1404 |
1384 for (int times = 0; times < benchmark_iterations_; ++times) { | 1405 for (int times = 0; times < benchmark_iterations_; ++times) { |
1385 int ret = | 1406 int ret = |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1437 ((benchmark_height_ - (benchmark_height_ * 360 / 480)) / 2 + 1) & ~1; | 1458 ((benchmark_height_ - (benchmark_height_ * 360 / 480)) / 2 + 1) & ~1; |
1438 const int kDestWidth = benchmark_width_; | 1459 const int kDestWidth = benchmark_width_; |
1439 const int kDestHeight = benchmark_height_ - crop_y * 2; | 1460 const int kDestHeight = benchmark_height_ - crop_y * 2; |
1440 const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); | 1461 const int kStrideUV = SUBSAMPLE(kWidth, SUBSAMP_X); |
1441 const int sample_size = | 1462 const int sample_size = |
1442 kWidth * kHeight + kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y) * 2; | 1463 kWidth * kHeight + kStrideUV * SUBSAMPLE(kHeight, SUBSAMP_Y) * 2; |
1443 align_buffer_page_end(src_y, sample_size); | 1464 align_buffer_page_end(src_y, sample_size); |
1444 uint8* src_uv = src_y + kWidth * kHeight; | 1465 uint8* src_uv = src_y + kWidth * kHeight; |
1445 | 1466 |
1446 align_buffer_page_end(dst_y, kDestWidth * kDestHeight); | 1467 align_buffer_page_end(dst_y, kDestWidth * kDestHeight); |
1447 align_buffer_page_end(dst_u, SUBSAMPLE(kDestWidth, SUBSAMP_X) * | 1468 align_buffer_page_end( |
1448 SUBSAMPLE(kDestHeight, SUBSAMP_Y)); | 1469 dst_u, |
1449 align_buffer_page_end(dst_v, SUBSAMPLE(kDestWidth, SUBSAMP_X) * | 1470 SUBSAMPLE(kDestWidth, SUBSAMP_X) * SUBSAMPLE(kDestHeight, SUBSAMP_Y)); |
1450 SUBSAMPLE(kDestHeight, SUBSAMP_Y)); | 1471 align_buffer_page_end( |
| 1472 dst_v, |
| 1473 SUBSAMPLE(kDestWidth, SUBSAMP_X) * SUBSAMPLE(kDestHeight, SUBSAMP_Y)); |
1451 | 1474 |
1452 align_buffer_page_end(dst_y_2, kDestWidth * kDestHeight); | 1475 align_buffer_page_end(dst_y_2, kDestWidth * kDestHeight); |
1453 align_buffer_page_end(dst_u_2, SUBSAMPLE(kDestWidth, SUBSAMP_X) * | 1476 align_buffer_page_end( |
1454 SUBSAMPLE(kDestHeight, SUBSAMP_Y)); | 1477 dst_u_2, |
1455 align_buffer_page_end(dst_v_2, SUBSAMPLE(kDestWidth, SUBSAMP_X) * | 1478 SUBSAMPLE(kDestWidth, SUBSAMP_X) * SUBSAMPLE(kDestHeight, SUBSAMP_Y)); |
1456 SUBSAMPLE(kDestHeight, SUBSAMP_Y)); | 1479 align_buffer_page_end( |
| 1480 dst_v_2, |
| 1481 SUBSAMPLE(kDestWidth, SUBSAMP_X) * SUBSAMPLE(kDestHeight, SUBSAMP_Y)); |
1457 | 1482 |
1458 for (int i = 0; i < kHeight * kWidth; ++i) { | 1483 for (int i = 0; i < kHeight * kWidth; ++i) { |
1459 src_y[i] = (fastrand() & 0xff); | 1484 src_y[i] = (fastrand() & 0xff); |
1460 } | 1485 } |
1461 for (int i = 0; i < (SUBSAMPLE(kHeight, SUBSAMP_Y) * kStrideUV) * 2; ++i) { | 1486 for (int i = 0; i < (SUBSAMPLE(kHeight, SUBSAMP_Y) * kStrideUV) * 2; ++i) { |
1462 src_uv[i] = (fastrand() & 0xff); | 1487 src_uv[i] = (fastrand() & 0xff); |
1463 } | 1488 } |
1464 memset(dst_y, 1, kDestWidth * kDestHeight); | 1489 memset(dst_y, 1, kDestWidth * kDestHeight); |
1465 memset(dst_u, 2, | 1490 memset(dst_u, 2, |
1466 SUBSAMPLE(kDestWidth, SUBSAMP_X) * SUBSAMPLE(kDestHeight, SUBSAMP_Y)); | 1491 SUBSAMPLE(kDestWidth, SUBSAMP_X) * SUBSAMPLE(kDestHeight, SUBSAMP_Y)); |
(...skipping 412 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1879 benchmark_width_, _Invert, -, 0, FMT_C, BPP_C, 0) \ | 1904 benchmark_width_, _Invert, -, 0, FMT_C, BPP_C, 0) \ |
1880 TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ | 1905 TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ |
1881 benchmark_width_, _Opt, +, 0, FMT_C, BPP_C, 0) \ | 1906 benchmark_width_, _Opt, +, 0, FMT_C, BPP_C, 0) \ |
1882 TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ | 1907 TESTQPLANARTOEI(FMT_PLANAR, SUBSAMP_X, SUBSAMP_Y, FMT_B, SUB_B, BPP_B, \ |
1883 benchmark_width_, _Premult, +, 0, FMT_C, BPP_C, 1) | 1908 benchmark_width_, _Premult, +, 0, FMT_C, BPP_C, 1) |
1884 | 1909 |
1885 TESTQPLANARTOE(I420Alpha, 2, 2, ARGB, 1, 4, ABGR, 4) | 1910 TESTQPLANARTOE(I420Alpha, 2, 2, ARGB, 1, 4, ABGR, 4) |
1886 TESTQPLANARTOE(I420Alpha, 2, 2, ABGR, 1, 4, ARGB, 4) | 1911 TESTQPLANARTOE(I420Alpha, 2, 2, ABGR, 1, 4, ARGB, 4) |
1887 | 1912 |
1888 } // namespace libyuv | 1913 } // namespace libyuv |
OLD | NEW |