1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/gfx/2d/unittest/TestScaling.cpp Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,249 @@
1.4 +/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
1.5 + * This Source Code Form is subject to the terms of the Mozilla Public
1.6 + * License, v. 2.0. If a copy of the MPL was not distributed with this
1.7 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
1.8 +
1.9 +#include "TestScaling.h"
1.10 +
1.11 +#include "ImageScaling.h"
1.12 +
1.13 +using namespace mozilla::gfx;
1.14 +
1.15 +TestScaling::TestScaling()
1.16 +{
1.17 + REGISTER_TEST(TestScaling, BasicHalfScale);
1.18 + REGISTER_TEST(TestScaling, DoubleHalfScale);
1.19 + REGISTER_TEST(TestScaling, UnevenHalfScale);
1.20 + REGISTER_TEST(TestScaling, OddStrideHalfScale);
1.21 + REGISTER_TEST(TestScaling, VerticalHalfScale);
1.22 + REGISTER_TEST(TestScaling, HorizontalHalfScale);
1.23 + REGISTER_TEST(TestScaling, MixedHalfScale);
1.24 +}
1.25 +
1.26 +void
1.27 +TestScaling::BasicHalfScale()
1.28 +{
1.29 + std::vector<uint8_t> data;
1.30 + data.resize(500 * 500 * 4);
1.31 +
1.32 + uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
1.33 + for (int y = 0; y < 500; y += 2) {
1.34 + for (int x = 0; x < 500; x += 2) {
1.35 + pixels[y * 500 + x] = 0xff00ff00;
1.36 + pixels[y * 500 + x + 1] = 0xff00ffff;
1.37 + pixels[(y + 1) * 500 + x] = 0xff000000;
1.38 + pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
1.39 + }
1.40 + }
1.41 + ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(500, 500));
1.42 +
1.43 + scaler.ScaleForSize(IntSize(220, 240));
1.44 +
1.45 + VERIFY(scaler.GetSize().width == 250);
1.46 + VERIFY(scaler.GetSize().height == 250);
1.47 +
1.48 + pixels = (uint32_t*)scaler.GetScaledData();
1.49 +
1.50 + for (int y = 0; y < 250; y++) {
1.51 + for (int x = 0; x < 250; x++) {
1.52 + VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f7f);
1.53 + }
1.54 + }
1.55 +}
1.56 +
1.57 +void
1.58 +TestScaling::DoubleHalfScale()
1.59 +{
1.60 + std::vector<uint8_t> data;
1.61 + data.resize(500 * 500 * 4);
1.62 +
1.63 + uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
1.64 + for (int y = 0; y < 500; y += 2) {
1.65 + for (int x = 0; x < 500; x += 2) {
1.66 + pixels[y * 500 + x] = 0xff00ff00;
1.67 + pixels[y * 500 + x + 1] = 0xff00ffff;
1.68 + pixels[(y + 1) * 500 + x] = 0xff000000;
1.69 + pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
1.70 + }
1.71 + }
1.72 + ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(500, 500));
1.73 +
1.74 + scaler.ScaleForSize(IntSize(120, 110));
1.75 + VERIFY(scaler.GetSize().width == 125);
1.76 + VERIFY(scaler.GetSize().height == 125);
1.77 +
1.78 + pixels = (uint32_t*)scaler.GetScaledData();
1.79 +
1.80 + for (int y = 0; y < 125; y++) {
1.81 + for (int x = 0; x < 125; x++) {
1.82 + VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f7f);
1.83 + }
1.84 + }
1.85 +}
1.86 +
1.87 +void
1.88 +TestScaling::UnevenHalfScale()
1.89 +{
1.90 + std::vector<uint8_t> data;
1.91 + // Use a 16-byte aligned stride still, we test none-aligned strides
1.92 + // separately.
1.93 + data.resize(499 * 500 * 4);
1.94 +
1.95 + uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
1.96 + for (int y = 0; y < 500; y += 2) {
1.97 + for (int x = 0; x < 500; x += 2) {
1.98 + pixels[y * 500 + x] = 0xff00ff00;
1.99 + if (x < 498) {
1.100 + pixels[y * 500 + x + 1] = 0xff00ffff;
1.101 + }
1.102 + if (y < 498) {
1.103 + pixels[(y + 1) * 500 + x] = 0xff000000;
1.104 + if (x < 498) {
1.105 + pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
1.106 + }
1.107 + }
1.108 + }
1.109 + }
1.110 + ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(499, 499));
1.111 +
1.112 + scaler.ScaleForSize(IntSize(220, 220));
1.113 + VERIFY(scaler.GetSize().width == 249);
1.114 + VERIFY(scaler.GetSize().height == 249);
1.115 +
1.116 + pixels = (uint32_t*)scaler.GetScaledData();
1.117 +
1.118 + for (int y = 0; y < 249; y++) {
1.119 + for (int x = 0; x < 249; x++) {
1.120 + VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f7f);
1.121 + }
1.122 + }
1.123 +}
1.124 +
1.125 +void
1.126 +TestScaling::OddStrideHalfScale()
1.127 +{
1.128 + std::vector<uint8_t> data;
1.129 + // Use a 4-byte aligned stride to test if that doesn't cause any issues.
1.130 + data.resize(499 * 499 * 4);
1.131 +
1.132 + uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
1.133 + for (int y = 0; y < 500; y += 2) {
1.134 + for (int x = 0; x < 500; x += 2) {
1.135 + pixels[y * 499 + x] = 0xff00ff00;
1.136 + if (x < 498) {
1.137 + pixels[y * 499 + x + 1] = 0xff00ffff;
1.138 + }
1.139 + if (y < 498) {
1.140 + pixels[(y + 1) * 499 + x] = 0xff000000;
1.141 + if (x < 498) {
1.142 + pixels[(y + 1) * 499 + x + 1] = 0xff0000ff;
1.143 + }
1.144 + }
1.145 + }
1.146 + }
1.147 + ImageHalfScaler scaler(&data.front(), 499 * 4, IntSize(499, 499));
1.148 +
1.149 + scaler.ScaleForSize(IntSize(220, 220));
1.150 + VERIFY(scaler.GetSize().width == 249);
1.151 + VERIFY(scaler.GetSize().height == 249);
1.152 +
1.153 + pixels = (uint32_t*)scaler.GetScaledData();
1.154 +
1.155 + for (int y = 0; y < 249; y++) {
1.156 + for (int x = 0; x < 249; x++) {
1.157 + VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f7f);
1.158 + }
1.159 + }
1.160 +}
1.161 +void
1.162 +TestScaling::VerticalHalfScale()
1.163 +{
1.164 + std::vector<uint8_t> data;
1.165 + data.resize(500 * 500 * 4);
1.166 +
1.167 + uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
1.168 + for (int y = 0; y < 500; y += 2) {
1.169 + for (int x = 0; x < 500; x += 2) {
1.170 + pixels[y * 500 + x] = 0xff00ff00;
1.171 + pixels[y * 500 + x + 1] = 0xff00ffff;
1.172 + pixels[(y + 1) * 500 + x] = 0xff000000;
1.173 + pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
1.174 + }
1.175 + }
1.176 + ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(500, 500));
1.177 +
1.178 + scaler.ScaleForSize(IntSize(400, 240));
1.179 + VERIFY(scaler.GetSize().width == 500);
1.180 + VERIFY(scaler.GetSize().height == 250);
1.181 +
1.182 + pixels = (uint32_t*)scaler.GetScaledData();
1.183 +
1.184 + for (int y = 0; y < 250; y++) {
1.185 + for (int x = 0; x < 500; x += 2) {
1.186 + VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f00);
1.187 + VERIFY(pixels[y * (scaler.GetStride() / 4) + x + 1] == 0xff007fff);
1.188 + }
1.189 + }
1.190 +}
1.191 +
1.192 +void
1.193 +TestScaling::HorizontalHalfScale()
1.194 +{
1.195 + std::vector<uint8_t> data;
1.196 + data.resize(520 * 500 * 4);
1.197 +
1.198 + uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
1.199 + for (int y = 0; y < 500; y ++) {
1.200 + for (int x = 0; x < 520; x += 8) {
1.201 + pixels[y * 520 + x] = 0xff00ff00;
1.202 + pixels[y * 520 + x + 1] = 0xff00ffff;
1.203 + pixels[y * 520 + x + 2] = 0xff000000;
1.204 + pixels[y * 520 + x + 3] = 0xff0000ff;
1.205 + pixels[y * 520 + x + 4] = 0xffff00ff;
1.206 + pixels[y * 520 + x + 5] = 0xff0000ff;
1.207 + pixels[y * 520 + x + 6] = 0xffffffff;
1.208 + pixels[y * 520 + x + 7] = 0xff0000ff;
1.209 + }
1.210 + }
1.211 + ImageHalfScaler scaler(&data.front(), 520 * 4, IntSize(520, 500));
1.212 +
1.213 + scaler.ScaleForSize(IntSize(240, 400));
1.214 + VERIFY(scaler.GetSize().width == 260);
1.215 + VERIFY(scaler.GetSize().height == 500);
1.216 +
1.217 + pixels = (uint32_t*)scaler.GetScaledData();
1.218 +
1.219 + for (int y = 0; y < 500; y++) {
1.220 + for (int x = 0; x < 260; x += 4) {
1.221 + VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff00ff7f);
1.222 + VERIFY(pixels[y * (scaler.GetStride() / 4) + x + 1] == 0xff00007f);
1.223 + VERIFY(pixels[y * (scaler.GetStride() / 4) + x + 2] == 0xff7f00ff);
1.224 + VERIFY(pixels[y * (scaler.GetStride() / 4) + x + 3] == 0xff7f7fff);
1.225 + }
1.226 + }
1.227 +}
1.228 +
1.229 +void
1.230 +TestScaling::MixedHalfScale()
1.231 +{
1.232 + std::vector<uint8_t> data;
1.233 + data.resize(500 * 500 * 4);
1.234 +
1.235 + uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
1.236 + for (int y = 0; y < 500; y += 2) {
1.237 + for (int x = 0; x < 500; x += 2) {
1.238 + pixels[y * 500 + x] = 0xff00ff00;
1.239 + pixels[y * 500 + x + 1] = 0xff00ffff;
1.240 + pixels[(y + 1) * 500 + x] = 0xff000000;
1.241 + pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
1.242 + }
1.243 + }
1.244 + ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(500, 500));
1.245 +
1.246 + scaler.ScaleForSize(IntSize(120, 240));
1.247 + VERIFY(scaler.GetSize().width == 125);
1.248 + VERIFY(scaler.GetSize().height == 250);
1.249 + scaler.ScaleForSize(IntSize(240, 120));
1.250 + VERIFY(scaler.GetSize().width == 250);
1.251 + VERIFY(scaler.GetSize().height == 125);
1.252 +}
