1 /* 2 * libjingle 3 * Copyright 2010 Google Inc. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * 3. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO 19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #include <sstream> 29 30 #include "libyuv/cpu_id.h" 31 #include "libyuv/scale.h" 32 #include "talk/media/base/testutils.h" 33 #include "webrtc/base/basictypes.h" 34 #include "webrtc/base/flags.h" 35 #include "webrtc/base/gunit.h" 36 #include "webrtc/base/scoped_ptr.h" 37 38 #if defined(_MSC_VER) 39 #define ALIGN16(var) __declspec(align(16)) var 40 #else 41 #define ALIGN16(var) var __attribute__((aligned(16))) 42 #endif 43 44 using cricket::LoadPlanarYuvTestImage; 45 using cricket::DumpPlanarYuvTestImage; 46 using rtc::scoped_ptr; 47 48 DEFINE_bool(yuvscaler_dump, false, 49 "whether to write out scaled images for inspection"); 50 DEFINE_int(yuvscaler_repeat, 1, 51 "how many times to perform each scaling operation (for perf testing)"); 52 53 static const int kAlignment = 16; 54 55 // TEST_UNCACHED flushes cache to test real memory performance. 56 // TEST_RSTSC uses cpu cycles for more accurate benchmark of the scale function. 57 #ifndef __arm__ 58 // #define TEST_UNCACHED 1 59 // #define TEST_RSTSC 1 60 #endif 61 62 #if defined(TEST_UNCACHED) || defined(TEST_RSTSC) 63 #ifdef _MSC_VER 64 #include <emmintrin.h> // NOLINT 65 #endif 66 67 #if defined(__GNUC__) && defined(__i386__) 68 static inline uint64_t __rdtsc(void) { 69 uint32_t a, d; 70 __asm__ volatile("rdtsc" : "=a" (a), "=d" (d)); 71 return (reinterpret_cast<uint64_t>(d) << 32) + a; 72 } 73 74 static inline void _mm_clflush(volatile void *__p) { 75 asm volatile("clflush %0" : "+m" (*(volatile char *)__p)); 76 } 77 #endif 78 79 static void FlushCache(uint8_t* dst, int count) { 80 while (count >= 32) { 81 _mm_clflush(dst); 82 dst += 32; 83 count -= 32; 84 } 85 } 86 #endif 87 88 class YuvScalerTest : public testing::Test { 89 protected: 90 virtual void SetUp() { 91 dump_ = *rtc::FlagList::Lookup("yuvscaler_dump")->bool_variable(); 92 repeat_ = *rtc::FlagList::Lookup("yuvscaler_repeat")->int_variable(); 93 } 94 95 // Scale an image and compare against a Lanczos-filtered test image. 96 // Lanczos is considered to be the "ideal" image resampling method, so we try 97 // to get as close to that as possible, while being as fast as possible. 98 bool TestScale(int iw, int ih, int ow, int oh, int offset, bool usefile, 99 bool optimize, int cpuflags, bool interpolate, 100 int memoffset, double* error) { 101 *error = 0.; 102 size_t isize = I420_SIZE(iw, ih); 103 size_t osize = I420_SIZE(ow, oh); 104 scoped_ptr<uint8_t[]> ibuffer( 105 new uint8_t[isize + kAlignment + memoffset]()); 106 scoped_ptr<uint8_t[]> obuffer( 107 new uint8_t[osize + kAlignment + memoffset]()); 108 scoped_ptr<uint8_t[]> xbuffer( 109 new uint8_t[osize + kAlignment + memoffset]()); 110 111 uint8_t* ibuf = ALIGNP(ibuffer.get(), kAlignment) + memoffset; 112 uint8_t* obuf = ALIGNP(obuffer.get(), kAlignment) + memoffset; 113 uint8_t* xbuf = ALIGNP(xbuffer.get(), kAlignment) + memoffset; 114 115 if (usefile) { 116 if (!LoadPlanarYuvTestImage("faces", iw, ih, ibuf) || 117 !LoadPlanarYuvTestImage("faces", ow, oh, xbuf)) { 118 LOG(LS_ERROR) << "Failed to load image"; 119 return false; 120 } 121 } else { 122 // These are used to test huge images. 123 memset(ibuf, 213, isize); // Input is constant color. 124 memset(obuf, 100, osize); // Output set to something wrong for now. 125 memset(xbuf, 213, osize); // Expected result. 126 } 127 128 #ifdef TEST_UNCACHED 129 FlushCache(ibuf, isize); 130 FlushCache(obuf, osize); 131 FlushCache(xbuf, osize); 132 #endif 133 134 // Scale down. 135 // If cpu true, disable cpu optimizations. Else allow auto detect 136 // TODO(fbarchard): set flags for libyuv 137 libyuv::MaskCpuFlags(cpuflags); 138 #ifdef TEST_RSTSC 139 uint64_t t = 0; 140 #endif 141 for (int i = 0; i < repeat_; ++i) { 142 #ifdef TEST_UNCACHED 143 FlushCache(ibuf, isize); 144 FlushCache(obuf, osize); 145 #endif 146 #ifdef TEST_RSTSC 147 uint64_t t1 = __rdtsc(); 148 #endif 149 EXPECT_EQ(0, libyuv::ScaleOffset(ibuf, iw, ih, obuf, ow, oh, 150 offset, interpolate)); 151 #ifdef TEST_RSTSC 152 uint64_t t2 = __rdtsc(); 153 t += t2 - t1; 154 #endif 155 } 156 157 #ifdef TEST_RSTSC 158 LOG(LS_INFO) << "Time: " << std::setw(9) << t; 159 #endif 160 161 if (dump_) { 162 const testing::TestInfo* const test_info = 163 testing::UnitTest::GetInstance()->current_test_info(); 164 std::string test_name(test_info->name()); 165 DumpPlanarYuvTestImage(test_name, obuf, ow, oh); 166 } 167 168 double sse = cricket::ComputeSumSquareError(obuf, xbuf, osize); 169 *error = sse / osize; // Mean Squared Error. 170 double PSNR = cricket::ComputePSNR(sse, osize); 171 LOG(LS_INFO) << "Image MSE: " << 172 std::setw(6) << std::setprecision(4) << *error << 173 " Image PSNR: " << PSNR; 174 return true; 175 } 176 177 // Returns the index of the first differing byte. Easier to debug than memcmp. 178 static int FindDiff(const uint8_t* buf1, const uint8_t* buf2, int len) { 179 int i = 0; 180 while (i < len && buf1[i] == buf2[i]) { 181 i++; 182 } 183 return (i < len) ? i : -1; 184 } 185 186 protected: 187 bool dump_; 188 int repeat_; 189 }; 190 191 // Tests straight copy of data. 192 TEST_F(YuvScalerTest, TestCopy) { 193 const int iw = 640, ih = 360; 194 const int ow = 640, oh = 360; 195 ALIGN16(uint8_t ibuf[I420_SIZE(iw, ih)]); 196 ALIGN16(uint8_t obuf[I420_SIZE(ow, oh)]); 197 198 // Load the frame, scale it, check it. 199 ASSERT_TRUE(LoadPlanarYuvTestImage("faces", iw, ih, ibuf)); 200 for (int i = 0; i < repeat_; ++i) { 201 libyuv::ScaleOffset(ibuf, iw, ih, obuf, ow, oh, 0, false); 202 } 203 if (dump_) DumpPlanarYuvTestImage("TestCopy", obuf, ow, oh); 204 EXPECT_EQ(-1, FindDiff(obuf, ibuf, sizeof(ibuf))); 205 } 206 207 // Tests copy from 4:3 to 16:9. 208 TEST_F(YuvScalerTest, TestOffset16_10Copy) { 209 const int iw = 640, ih = 360; 210 const int ow = 640, oh = 480; 211 const int offset = (480 - 360) / 2; 212 scoped_ptr<uint8_t[]> ibuffer(new uint8_t[I420_SIZE(iw, ih) + kAlignment]); 213 scoped_ptr<uint8_t[]> obuffer(new uint8_t[I420_SIZE(ow, oh) + kAlignment]); 214 215 uint8_t* ibuf = ALIGNP(ibuffer.get(), kAlignment); 216 uint8_t* obuf = ALIGNP(obuffer.get(), kAlignment); 217 218 // Load the frame, scale it, check it. 219 ASSERT_TRUE(LoadPlanarYuvTestImage("faces", iw, ih, ibuf)); 220 221 // Clear to black, which is Y = 0 and U and V = 128 222 memset(obuf, 0, ow * oh); 223 memset(obuf + ow * oh, 128, ow * oh / 2); 224 for (int i = 0; i < repeat_; ++i) { 225 libyuv::ScaleOffset(ibuf, iw, ih, obuf, ow, oh, offset, false); 226 } 227 if (dump_) DumpPlanarYuvTestImage("TestOffsetCopy16_9", obuf, ow, oh); 228 EXPECT_EQ(-1, FindDiff(obuf + ow * offset, 229 ibuf, 230 iw * ih)); 231 EXPECT_EQ(-1, FindDiff(obuf + ow * oh + ow * offset / 4, 232 ibuf + iw * ih, 233 iw * ih / 4)); 234 EXPECT_EQ(-1, FindDiff(obuf + ow * oh * 5 / 4 + ow * offset / 4, 235 ibuf + iw * ih * 5 / 4, 236 iw * ih / 4)); 237 } 238 239 // The following are 'cpu' flag values: 240 // Allow all SIMD optimizations 241 #define ALLFLAGS -1 242 // Disable SSSE3 but allow other forms of SIMD (SSE2) 243 #define NOSSSE3 ~libyuv::kCpuHasSSSE3 244 // Disable SSE2 and SSSE3 245 #define NOSSE ~libyuv::kCpuHasSSE2 & ~libyuv::kCpuHasSSSE3 246 247 // TEST_M scale factor with variations of opt, align, int 248 #define TEST_M(name, iwidth, iheight, owidth, oheight, mse) \ 249 TEST_F(YuvScalerTest, name##Ref) { \ 250 double error; \ 251 EXPECT_TRUE(TestScale(iwidth, iheight, owidth, oheight, \ 252 0, true, false, ALLFLAGS, false, 0, &error)); \ 253 EXPECT_LE(error, mse); \ 254 } \ 255 TEST_F(YuvScalerTest, name##OptAligned) { \ 256 double error; \ 257 EXPECT_TRUE(TestScale(iwidth, iheight, owidth, oheight, \ 258 0, true, true, ALLFLAGS, false, 0, &error)); \ 259 EXPECT_LE(error, mse); \ 260 } \ 261 TEST_F(YuvScalerTest, name##OptUnaligned) { \ 262 double error; \ 263 EXPECT_TRUE(TestScale(iwidth, iheight, owidth, oheight, \ 264 0, true, true, ALLFLAGS, false, 1, &error)); \ 265 EXPECT_LE(error, mse); \ 266 } \ 267 TEST_F(YuvScalerTest, name##OptSSE2) { \ 268 double error; \ 269 EXPECT_TRUE(TestScale(iwidth, iheight, owidth, oheight, \ 270 0, true, true, NOSSSE3, false, 0, &error)); \ 271 EXPECT_LE(error, mse); \ 272 } \ 273 TEST_F(YuvScalerTest, name##OptC) { \ 274 double error; \ 275 EXPECT_TRUE(TestScale(iwidth, iheight, owidth, oheight, \ 276 0, true, true, NOSSE, false, 0, &error)); \ 277 EXPECT_LE(error, mse); \ 278 } \ 279 TEST_F(YuvScalerTest, name##IntRef) { \ 280 double error; \ 281 EXPECT_TRUE(TestScale(iwidth, iheight, owidth, oheight, \ 282 0, true, false, ALLFLAGS, true, 0, &error)); \ 283 EXPECT_LE(error, mse); \ 284 } \ 285 TEST_F(YuvScalerTest, name##IntOptAligned) { \ 286 double error; \ 287 EXPECT_TRUE(TestScale(iwidth, iheight, owidth, oheight, \ 288 0, true, true, ALLFLAGS, true, 0, &error)); \ 289 EXPECT_LE(error, mse); \ 290 } \ 291 TEST_F(YuvScalerTest, name##IntOptUnaligned) { \ 292 double error; \ 293 EXPECT_TRUE(TestScale(iwidth, iheight, owidth, oheight, \ 294 0, true, true, ALLFLAGS, true, 1, &error)); \ 295 EXPECT_LE(error, mse); \ 296 } \ 297 TEST_F(YuvScalerTest, name##IntOptSSE2) { \ 298 double error; \ 299 EXPECT_TRUE(TestScale(iwidth, iheight, owidth, oheight, \ 300 0, true, true, NOSSSE3, true, 0, &error)); \ 301 EXPECT_LE(error, mse); \ 302 } \ 303 TEST_F(YuvScalerTest, name##IntOptC) { \ 304 double error; \ 305 EXPECT_TRUE(TestScale(iwidth, iheight, owidth, oheight, \ 306 0, true, true, NOSSE, true, 0, &error)); \ 307 EXPECT_LE(error, mse); \ 308 } 309 310 #define TEST_H(name, iwidth, iheight, owidth, oheight, opt, cpu, intr, mse) \ 311 TEST_F(YuvScalerTest, name) { \ 312 double error; \ 313 EXPECT_TRUE(TestScale(iwidth, iheight, owidth, oheight, \ 314 0, false, opt, cpu, intr, 0, &error)); \ 315 EXPECT_LE(error, mse); \ 316 } 317 318 // Test 4x3 aspect ratio scaling 319 320 // Tests 1/1x scale down. 321 TEST_M(TestScale4by3Down11, 640, 480, 640, 480, 0) 322 323 // Tests 3/4x scale down. 324 TEST_M(TestScale4by3Down34, 640, 480, 480, 360, 60) 325 326 // Tests 1/2x scale down. 327 TEST_M(TestScale4by3Down12, 640, 480, 320, 240, 60) 328 329 // Tests 3/8x scale down. 330 TEST_M(TestScale4by3Down38, 640, 480, 240, 180, 60) 331 332 // Tests 1/4x scale down.. 333 TEST_M(TestScale4by3Down14, 640, 480, 160, 120, 60) 334 335 // Tests 3/16x scale down. 336 TEST_M(TestScale4by3Down316, 640, 480, 120, 90, 120) 337 338 // Tests 1/8x scale down. 339 TEST_M(TestScale4by3Down18, 640, 480, 80, 60, 150) 340 341 // Tests 2/3x scale down. 342 TEST_M(TestScale4by3Down23, 480, 360, 320, 240, 60) 343 344 // Tests 4/3x scale up. 345 TEST_M(TestScale4by3Up43, 480, 360, 640, 480, 60) 346 347 // Tests 2/1x scale up. 348 TEST_M(TestScale4by3Up21, 320, 240, 640, 480, 60) 349 350 // Tests 4/1x scale up. 351 TEST_M(TestScale4by3Up41, 160, 120, 640, 480, 80) 352 353 // Test 16x10 aspect ratio scaling 354 355 // Tests 1/1x scale down. 356 TEST_M(TestScale16by10Down11, 640, 400, 640, 400, 0) 357 358 // Tests 3/4x scale down. 359 TEST_M(TestScale16by10Down34, 640, 400, 480, 300, 60) 360 361 // Tests 1/2x scale down. 362 TEST_M(TestScale16by10Down12, 640, 400, 320, 200, 60) 363 364 // Tests 3/8x scale down. 365 TEST_M(TestScale16by10Down38, 640, 400, 240, 150, 60) 366 367 // Tests 1/4x scale down.. 368 TEST_M(TestScale16by10Down14, 640, 400, 160, 100, 60) 369 370 // Tests 3/16x scale down. 371 TEST_M(TestScale16by10Down316, 640, 400, 120, 75, 120) 372 373 // Tests 1/8x scale down. 374 TEST_M(TestScale16by10Down18, 640, 400, 80, 50, 150) 375 376 // Tests 2/3x scale down. 377 TEST_M(TestScale16by10Down23, 480, 300, 320, 200, 60) 378 379 // Tests 4/3x scale up. 380 TEST_M(TestScale16by10Up43, 480, 300, 640, 400, 60) 381 382 // Tests 2/1x scale up. 383 TEST_M(TestScale16by10Up21, 320, 200, 640, 400, 60) 384 385 // Tests 4/1x scale up. 386 TEST_M(TestScale16by10Up41, 160, 100, 640, 400, 80) 387 388 // Test 16x9 aspect ratio scaling 389 390 // Tests 1/1x scale down. 391 TEST_M(TestScaleDown11, 640, 360, 640, 360, 0) 392 393 // Tests 3/4x scale down. 394 TEST_M(TestScaleDown34, 640, 360, 480, 270, 60) 395 396 // Tests 1/2x scale down. 397 TEST_M(TestScaleDown12, 640, 360, 320, 180, 60) 398 399 // Tests 3/8x scale down. 400 TEST_M(TestScaleDown38, 640, 360, 240, 135, 60) 401 402 // Tests 1/4x scale down.. 403 TEST_M(TestScaleDown14, 640, 360, 160, 90, 60) 404 405 // Tests 3/16x scale down. 406 TEST_M(TestScaleDown316, 640, 360, 120, 68, 120) 407 408 // Tests 1/8x scale down. 409 TEST_M(TestScaleDown18, 640, 360, 80, 45, 150) 410 411 // Tests 2/3x scale down. 412 TEST_M(TestScaleDown23, 480, 270, 320, 180, 60) 413 414 // Tests 4/3x scale up. 415 TEST_M(TestScaleUp43, 480, 270, 640, 360, 60) 416 417 // Tests 2/1x scale up. 418 TEST_M(TestScaleUp21, 320, 180, 640, 360, 60) 419 420 // Tests 4/1x scale up. 421 TEST_M(TestScaleUp41, 160, 90, 640, 360, 80) 422 423 // Test HD 4x3 aspect ratio scaling 424 425 // Tests 1/1x scale down. 426 TEST_M(TestScaleHD4x3Down11, 1280, 960, 1280, 960, 0) 427 428 // Tests 3/4x scale down. 429 TEST_M(TestScaleHD4x3Down34, 1280, 960, 960, 720, 60) 430 431 // Tests 1/2x scale down. 432 TEST_M(TestScaleHD4x3Down12, 1280, 960, 640, 480, 60) 433 434 // Tests 3/8x scale down. 435 TEST_M(TestScaleHD4x3Down38, 1280, 960, 480, 360, 60) 436 437 // Tests 1/4x scale down.. 438 TEST_M(TestScaleHD4x3Down14, 1280, 960, 320, 240, 60) 439 440 // Tests 3/16x scale down. 441 TEST_M(TestScaleHD4x3Down316, 1280, 960, 240, 180, 120) 442 443 // Tests 1/8x scale down. 444 TEST_M(TestScaleHD4x3Down18, 1280, 960, 160, 120, 150) 445 446 // Tests 2/3x scale down. 447 TEST_M(TestScaleHD4x3Down23, 960, 720, 640, 480, 60) 448 449 // Tests 4/3x scale up. 450 TEST_M(TestScaleHD4x3Up43, 960, 720, 1280, 960, 60) 451 452 // Tests 2/1x scale up. 453 TEST_M(TestScaleHD4x3Up21, 640, 480, 1280, 960, 60) 454 455 // Tests 4/1x scale up. 456 TEST_M(TestScaleHD4x3Up41, 320, 240, 1280, 960, 80) 457 458 // Test HD 16x10 aspect ratio scaling 459 460 // Tests 1/1x scale down. 461 TEST_M(TestScaleHD16x10Down11, 1280, 800, 1280, 800, 0) 462 463 // Tests 3/4x scale down. 464 TEST_M(TestScaleHD16x10Down34, 1280, 800, 960, 600, 60) 465 466 // Tests 1/2x scale down. 467 TEST_M(TestScaleHD16x10Down12, 1280, 800, 640, 400, 60) 468 469 // Tests 3/8x scale down. 470 TEST_M(TestScaleHD16x10Down38, 1280, 800, 480, 300, 60) 471 472 // Tests 1/4x scale down.. 473 TEST_M(TestScaleHD16x10Down14, 1280, 800, 320, 200, 60) 474 475 // Tests 3/16x scale down. 476 TEST_M(TestScaleHD16x10Down316, 1280, 800, 240, 150, 120) 477 478 // Tests 1/8x scale down. 479 TEST_M(TestScaleHD16x10Down18, 1280, 800, 160, 100, 150) 480 481 // Tests 2/3x scale down. 482 TEST_M(TestScaleHD16x10Down23, 960, 600, 640, 400, 60) 483 484 // Tests 4/3x scale up. 485 TEST_M(TestScaleHD16x10Up43, 960, 600, 1280, 800, 60) 486 487 // Tests 2/1x scale up. 488 TEST_M(TestScaleHD16x10Up21, 640, 400, 1280, 800, 60) 489 490 // Tests 4/1x scale up. 491 TEST_M(TestScaleHD16x10Up41, 320, 200, 1280, 800, 80) 492 493 // Test HD 16x9 aspect ratio scaling 494 495 // Tests 1/1x scale down. 496 TEST_M(TestScaleHDDown11, 1280, 720, 1280, 720, 0) 497 498 // Tests 3/4x scale down. 499 TEST_M(TestScaleHDDown34, 1280, 720, 960, 540, 60) 500 501 // Tests 1/2x scale down. 502 TEST_M(TestScaleHDDown12, 1280, 720, 640, 360, 60) 503 504 // Tests 3/8x scale down. 505 TEST_M(TestScaleHDDown38, 1280, 720, 480, 270, 60) 506 507 // Tests 1/4x scale down.. 508 TEST_M(TestScaleHDDown14, 1280, 720, 320, 180, 60) 509 510 // Tests 3/16x scale down. 511 TEST_M(TestScaleHDDown316, 1280, 720, 240, 135, 120) 512 513 // Tests 1/8x scale down. 514 TEST_M(TestScaleHDDown18, 1280, 720, 160, 90, 150) 515 516 // Tests 2/3x scale down. 517 TEST_M(TestScaleHDDown23, 960, 540, 640, 360, 60) 518 519 // Tests 4/3x scale up. 520 TEST_M(TestScaleHDUp43, 960, 540, 1280, 720, 60) 521 522 // Tests 2/1x scale up. 523 TEST_M(TestScaleHDUp21, 640, 360, 1280, 720, 60) 524 525 // Tests 4/1x scale up. 526 TEST_M(TestScaleHDUp41, 320, 180, 1280, 720, 80) 527 528 // Tests 1366x768 resolution for comparison to chromium scaler_bench 529 TEST_M(TestScaleHDUp1366, 1280, 720, 1366, 768, 10) 530 531 // Tests odd source/dest sizes. 3 less to make chroma odd as well. 532 TEST_M(TestScaleHDUp1363, 1277, 717, 1363, 765, 10) 533 534 // Tests 1/2x scale down, using optimized algorithm. 535 TEST_M(TestScaleOddDown12, 180, 100, 90, 50, 50) 536 537 // Tests bilinear scale down 538 TEST_M(TestScaleOddDownBilin, 160, 100, 90, 50, 120) 539 540 // Test huge buffer scales that are expected to use a different code path 541 // that avoids stack overflow but still work using point sampling. 542 // Max output size is 640 wide. 543 544 // Tests interpolated 1/8x scale down, using optimized algorithm. 545 TEST_H(TestScaleDown18HDOptInt, 6144, 48, 768, 6, true, ALLFLAGS, true, 1) 546 547 // Tests interpolated 1/8x scale down, using c_only optimized algorithm. 548 TEST_H(TestScaleDown18HDCOnlyOptInt, 6144, 48, 768, 6, true, NOSSE, true, 1) 549 550 // Tests interpolated 3/8x scale down, using optimized algorithm. 551 TEST_H(TestScaleDown38HDOptInt, 2048, 16, 768, 6, true, ALLFLAGS, true, 1) 552 553 // Tests interpolated 3/8x scale down, using no SSSE3 optimized algorithm. 554 TEST_H(TestScaleDown38HDNoSSSE3OptInt, 2048, 16, 768, 6, true, NOSSSE3, true, 1) 555 556 // Tests interpolated 3/8x scale down, using c_only optimized algorithm. 557 TEST_H(TestScaleDown38HDCOnlyOptInt, 2048, 16, 768, 6, true, NOSSE, true, 1) 558 559 // Tests interpolated 3/16x scale down, using optimized algorithm. 560 TEST_H(TestScaleDown316HDOptInt, 4096, 32, 768, 6, true, ALLFLAGS, true, 1) 561 562 // Tests interpolated 3/16x scale down, using no SSSE3 optimized algorithm. 563 TEST_H(TestScaleDown316HDNoSSSE3OptInt, 4096, 32, 768, 6, true, NOSSSE3, true, 564 1) 565 566 // Tests interpolated 3/16x scale down, using c_only optimized algorithm. 567 TEST_H(TestScaleDown316HDCOnlyOptInt, 4096, 32, 768, 6, true, NOSSE, true, 1) 568 569 // Test special sizes dont crash 570 // Tests scaling down to 1 pixel width 571 TEST_H(TestScaleDown1x6OptInt, 3, 24, 1, 6, true, ALLFLAGS, true, 4) 572 573 // Tests scaling down to 1 pixel height 574 TEST_H(TestScaleDown6x1OptInt, 24, 3, 6, 1, true, ALLFLAGS, true, 4) 575 576 // Tests scaling up from 1 pixel width 577 TEST_H(TestScaleUp1x6OptInt, 1, 6, 3, 24, true, ALLFLAGS, true, 4) 578 579 // Tests scaling up from 1 pixel height 580 TEST_H(TestScaleUp6x1OptInt, 6, 1, 24, 3, true, ALLFLAGS, true, 4) 581 582 // Test performance of a range of box filter scale sizes 583 584 // Tests interpolated 1/2x scale down, using optimized algorithm. 585 TEST_H(TestScaleDown2xHDOptInt, 1280, 720, 1280 / 2, 720 / 2, true, ALLFLAGS, 586 true, 1) 587 588 // Tests interpolated 1/3x scale down, using optimized algorithm. 589 TEST_H(TestScaleDown3xHDOptInt, 1280, 720, 1280 / 3, 720 / 3, true, ALLFLAGS, 590 true, 1) 591 592 // Tests interpolated 1/4x scale down, using optimized algorithm. 593 TEST_H(TestScaleDown4xHDOptInt, 1280, 720, 1280 / 4, 720 / 4, true, ALLFLAGS, 594 true, 1) 595 596 // Tests interpolated 1/5x scale down, using optimized algorithm. 597 TEST_H(TestScaleDown5xHDOptInt, 1280, 720, 1280 / 5, 720 / 5, true, ALLFLAGS, 598 true, 1) 599 600 // Tests interpolated 1/6x scale down, using optimized algorithm. 601 TEST_H(TestScaleDown6xHDOptInt, 1280, 720, 1280 / 6, 720 / 6, true, ALLFLAGS, 602 true, 1) 603 604 // Tests interpolated 1/7x scale down, using optimized algorithm. 605 TEST_H(TestScaleDown7xHDOptInt, 1280, 720, 1280 / 7, 720 / 7, true, ALLFLAGS, 606 true, 1) 607 608 // Tests interpolated 1/8x scale down, using optimized algorithm. 609 TEST_H(TestScaleDown8xHDOptInt, 1280, 720, 1280 / 8, 720 / 8, true, ALLFLAGS, 610 true, 1) 611 612 // Tests interpolated 1/8x scale down, using optimized algorithm. 613 TEST_H(TestScaleDown9xHDOptInt, 1280, 720, 1280 / 9, 720 / 9, true, ALLFLAGS, 614 true, 1) 615 616 // Tests interpolated 1/8x scale down, using optimized algorithm. 617 TEST_H(TestScaleDown10xHDOptInt, 1280, 720, 1280 / 10, 720 / 10, true, ALLFLAGS, 618 true, 1) 619
