tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

TestScaling.cpp (7314B)

      1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
      3 /* This Source Code Form is subject to the terms of the Mozilla Public
      4 * License, v. 2.0. If a copy of the MPL was not distributed with this
      5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 
      7 #include "TestScaling.h"
      8 
      9 #include "ImageScaling.h"
     10 
     11 using namespace mozilla::gfx;
     12 
     13 TestScaling::TestScaling() {
     14  REGISTER_TEST(TestScaling, BasicHalfScale);
     15  REGISTER_TEST(TestScaling, DoubleHalfScale);
     16  REGISTER_TEST(TestScaling, UnevenHalfScale);
     17  REGISTER_TEST(TestScaling, OddStrideHalfScale);
     18  REGISTER_TEST(TestScaling, VerticalHalfScale);
     19  REGISTER_TEST(TestScaling, HorizontalHalfScale);
     20  REGISTER_TEST(TestScaling, MixedHalfScale);
     21 }
     22 
     23 void TestScaling::BasicHalfScale() {
     24  std::vector<uint8_t> data;
     25  data.resize(500 * 500 * 4);
     26 
     27  uint32_t* pixels = reinterpret_cast<uint32_t*>(&data.front());
     28  for (int y = 0; y < 500; y += 2) {
     29    for (int x = 0; x < 500; x += 2) {
     30      pixels[y * 500 + x] = 0xff00ff00;
     31      pixels[y * 500 + x + 1] = 0xff00ffff;
     32      pixels[(y + 1) * 500 + x] = 0xff000000;
     33      pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
     34    }
     35  }
     36  ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(500, 500));
     37 
     38  scaler.ScaleForSize(IntSize(220, 240));
     39 
     40  VERIFY(scaler.GetSize().width == 250);
     41  VERIFY(scaler.GetSize().height == 250);
     42 
     43  pixels = (uint32_t*)scaler.GetScaledData();
     44 
     45  for (int y = 0; y < 250; y++) {
     46    for (int x = 0; x < 250; x++) {
     47      VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f7f);
     48    }
     49  }
     50 }
     51 
     52 void TestScaling::DoubleHalfScale() {
     53  std::vector<uint8_t> data;
     54  data.resize(500 * 500 * 4);
     55 
     56  uint32_t* pixels = reinterpret_cast<uint32_t*>(&data.front());
     57  for (int y = 0; y < 500; y += 2) {
     58    for (int x = 0; x < 500; x += 2) {
     59      pixels[y * 500 + x] = 0xff00ff00;
     60      pixels[y * 500 + x + 1] = 0xff00ffff;
     61      pixels[(y + 1) * 500 + x] = 0xff000000;
     62      pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
     63    }
     64  }
     65  ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(500, 500));
     66 
     67  scaler.ScaleForSize(IntSize(120, 110));
     68  VERIFY(scaler.GetSize().width == 125);
     69  VERIFY(scaler.GetSize().height == 125);
     70 
     71  pixels = (uint32_t*)scaler.GetScaledData();
     72 
     73  for (int y = 0; y < 125; y++) {
     74    for (int x = 0; x < 125; x++) {
     75      VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f7f);
     76    }
     77  }
     78 }
     79 
     80 void TestScaling::UnevenHalfScale() {
     81  std::vector<uint8_t> data;
     82  // Use a 16-byte aligned stride still, we test none-aligned strides
     83  // separately.
     84  data.resize(499 * 500 * 4);
     85 
     86  uint32_t* pixels = reinterpret_cast<uint32_t*>(&data.front());
     87  for (int y = 0; y < 500; y += 2) {
     88    for (int x = 0; x < 500; x += 2) {
     89      pixels[y * 500 + x] = 0xff00ff00;
     90      if (x < 498) {
     91        pixels[y * 500 + x + 1] = 0xff00ffff;
     92      }
     93      if (y < 498) {
     94        pixels[(y + 1) * 500 + x] = 0xff000000;
     95        if (x < 498) {
     96          pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
     97        }
     98      }
     99    }
    100  }
    101  ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(499, 499));
    102 
    103  scaler.ScaleForSize(IntSize(220, 220));
    104  VERIFY(scaler.GetSize().width == 249);
    105  VERIFY(scaler.GetSize().height == 249);
    106 
    107  pixels = (uint32_t*)scaler.GetScaledData();
    108 
    109  for (int y = 0; y < 249; y++) {
    110    for (int x = 0; x < 249; x++) {
    111      VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f7f);
    112    }
    113  }
    114 }
    115 
    116 void TestScaling::OddStrideHalfScale() {
    117  std::vector<uint8_t> data;
    118  // Use a 4-byte aligned stride to test if that doesn't cause any issues.
    119  data.resize(499 * 499 * 4);
    120 
    121  uint32_t* pixels = reinterpret_cast<uint32_t*>(&data.front());
    122  for (int y = 0; y < 500; y += 2) {
    123    for (int x = 0; x < 500; x += 2) {
    124      pixels[y * 499 + x] = 0xff00ff00;
    125      if (x < 498) {
    126        pixels[y * 499 + x + 1] = 0xff00ffff;
    127      }
    128      if (y < 498) {
    129        pixels[(y + 1) * 499 + x] = 0xff000000;
    130        if (x < 498) {
    131          pixels[(y + 1) * 499 + x + 1] = 0xff0000ff;
    132        }
    133      }
    134    }
    135  }
    136  ImageHalfScaler scaler(&data.front(), 499 * 4, IntSize(499, 499));
    137 
    138  scaler.ScaleForSize(IntSize(220, 220));
    139  VERIFY(scaler.GetSize().width == 249);
    140  VERIFY(scaler.GetSize().height == 249);
    141 
    142  pixels = (uint32_t*)scaler.GetScaledData();
    143 
    144  for (int y = 0; y < 249; y++) {
    145    for (int x = 0; x < 249; x++) {
    146      VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f7f);
    147    }
    148  }
    149 }
    150 void TestScaling::VerticalHalfScale() {
    151  std::vector<uint8_t> data;
    152  data.resize(500 * 500 * 4);
    153 
    154  uint32_t* pixels = reinterpret_cast<uint32_t*>(&data.front());
    155  for (int y = 0; y < 500; y += 2) {
    156    for (int x = 0; x < 500; x += 2) {
    157      pixels[y * 500 + x] = 0xff00ff00;
    158      pixels[y * 500 + x + 1] = 0xff00ffff;
    159      pixels[(y + 1) * 500 + x] = 0xff000000;
    160      pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
    161    }
    162  }
    163  ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(500, 500));
    164 
    165  scaler.ScaleForSize(IntSize(400, 240));
    166  VERIFY(scaler.GetSize().width == 500);
    167  VERIFY(scaler.GetSize().height == 250);
    168 
    169  pixels = (uint32_t*)scaler.GetScaledData();
    170 
    171  for (int y = 0; y < 250; y++) {
    172    for (int x = 0; x < 500; x += 2) {
    173      VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f00);
    174      VERIFY(pixels[y * (scaler.GetStride() / 4) + x + 1] == 0xff007fff);
    175    }
    176  }
    177 }
    178 
    179 void TestScaling::HorizontalHalfScale() {
    180  std::vector<uint8_t> data;
    181  data.resize(520 * 500 * 4);
    182 
    183  uint32_t* pixels = reinterpret_cast<uint32_t*>(&data.front());
    184  for (int y = 0; y < 500; y++) {
    185    for (int x = 0; x < 520; x += 8) {
    186      pixels[y * 520 + x] = 0xff00ff00;
    187      pixels[y * 520 + x + 1] = 0xff00ffff;
    188      pixels[y * 520 + x + 2] = 0xff000000;
    189      pixels[y * 520 + x + 3] = 0xff0000ff;
    190      pixels[y * 520 + x + 4] = 0xffff00ff;
    191      pixels[y * 520 + x + 5] = 0xff0000ff;
    192      pixels[y * 520 + x + 6] = 0xffffffff;
    193      pixels[y * 520 + x + 7] = 0xff0000ff;
    194    }
    195  }
    196  ImageHalfScaler scaler(&data.front(), 520 * 4, IntSize(520, 500));
    197 
    198  scaler.ScaleForSize(IntSize(240, 400));
    199  VERIFY(scaler.GetSize().width == 260);
    200  VERIFY(scaler.GetSize().height == 500);
    201 
    202  pixels = (uint32_t*)scaler.GetScaledData();
    203 
    204  for (int y = 0; y < 500; y++) {
    205    for (int x = 0; x < 260; x += 4) {
    206      VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff00ff7f);
    207      VERIFY(pixels[y * (scaler.GetStride() / 4) + x + 1] == 0xff00007f);
    208      VERIFY(pixels[y * (scaler.GetStride() / 4) + x + 2] == 0xff7f00ff);
    209      VERIFY(pixels[y * (scaler.GetStride() / 4) + x + 3] == 0xff7f7fff);
    210    }
    211  }
    212 }
    213 
    214 void TestScaling::MixedHalfScale() {
    215  std::vector<uint8_t> data;
    216  data.resize(500 * 500 * 4);
    217 
    218  uint32_t* pixels = reinterpret_cast<uint32_t*>(&data.front());
    219  for (int y = 0; y < 500; y += 2) {
    220    for (int x = 0; x < 500; x += 2) {
    221      pixels[y * 500 + x] = 0xff00ff00;
    222      pixels[y * 500 + x + 1] = 0xff00ffff;
    223      pixels[(y + 1) * 500 + x] = 0xff000000;
    224      pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
    225    }
    226  }
    227  ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(500, 500));
    228 
    229  scaler.ScaleForSize(IntSize(120, 240));
    230  VERIFY(scaler.GetSize().width == 125);
    231  VERIFY(scaler.GetSize().height == 250);
    232  scaler.ScaleForSize(IntSize(240, 120));
    233  VERIFY(scaler.GetSize().width == 250);
    234  VERIFY(scaler.GetSize().height == 125);
    235 }