gfx/2d/unittest/TestScaling.cpp@97036ab72558
gfx/2d/unittest/TestScaling.cpp
Tue, 06 Jan 2015 21:39:09 +0100
- author
- Michael Schloh von Bennewitz <michael@schloh.com>
- date
- Tue, 06 Jan 2015 21:39:09 +0100
- branch
- TOR_BUG_9701
- changeset 8
- 97036ab72558
- permissions
- -rw-r--r--
Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.
1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2 * This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6 #include "TestScaling.h"
8 #include "ImageScaling.h"
10 using namespace mozilla::gfx;
12 TestScaling::TestScaling()
13 {
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 }
23 void
24 TestScaling::BasicHalfScale()
25 {
26 std::vector<uint8_t> data;
27 data.resize(500 * 500 * 4);
29 uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
30 for (int y = 0; y < 500; y += 2) {
31 for (int x = 0; x < 500; x += 2) {
32 pixels[y * 500 + x] = 0xff00ff00;
33 pixels[y * 500 + x + 1] = 0xff00ffff;
34 pixels[(y + 1) * 500 + x] = 0xff000000;
35 pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
36 }
37 }
38 ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(500, 500));
40 scaler.ScaleForSize(IntSize(220, 240));
42 VERIFY(scaler.GetSize().width == 250);
43 VERIFY(scaler.GetSize().height == 250);
45 pixels = (uint32_t*)scaler.GetScaledData();
47 for (int y = 0; y < 250; y++) {
48 for (int x = 0; x < 250; x++) {
49 VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f7f);
50 }
51 }
52 }
54 void
55 TestScaling::DoubleHalfScale()
56 {
57 std::vector<uint8_t> data;
58 data.resize(500 * 500 * 4);
60 uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
61 for (int y = 0; y < 500; y += 2) {
62 for (int x = 0; x < 500; x += 2) {
63 pixels[y * 500 + x] = 0xff00ff00;
64 pixels[y * 500 + x + 1] = 0xff00ffff;
65 pixels[(y + 1) * 500 + x] = 0xff000000;
66 pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
67 }
68 }
69 ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(500, 500));
71 scaler.ScaleForSize(IntSize(120, 110));
72 VERIFY(scaler.GetSize().width == 125);
73 VERIFY(scaler.GetSize().height == 125);
75 pixels = (uint32_t*)scaler.GetScaledData();
77 for (int y = 0; y < 125; y++) {
78 for (int x = 0; x < 125; x++) {
79 VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f7f);
80 }
81 }
82 }
84 void
85 TestScaling::UnevenHalfScale()
86 {
87 std::vector<uint8_t> data;
88 // Use a 16-byte aligned stride still, we test none-aligned strides
89 // separately.
90 data.resize(499 * 500 * 4);
92 uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
93 for (int y = 0; y < 500; y += 2) {
94 for (int x = 0; x < 500; x += 2) {
95 pixels[y * 500 + x] = 0xff00ff00;
96 if (x < 498) {
97 pixels[y * 500 + x + 1] = 0xff00ffff;
98 }
99 if (y < 498) {
100 pixels[(y + 1) * 500 + x] = 0xff000000;
101 if (x < 498) {
102 pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
103 }
104 }
105 }
106 }
107 ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(499, 499));
109 scaler.ScaleForSize(IntSize(220, 220));
110 VERIFY(scaler.GetSize().width == 249);
111 VERIFY(scaler.GetSize().height == 249);
113 pixels = (uint32_t*)scaler.GetScaledData();
115 for (int y = 0; y < 249; y++) {
116 for (int x = 0; x < 249; x++) {
117 VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f7f);
118 }
119 }
120 }
122 void
123 TestScaling::OddStrideHalfScale()
124 {
125 std::vector<uint8_t> data;
126 // Use a 4-byte aligned stride to test if that doesn't cause any issues.
127 data.resize(499 * 499 * 4);
129 uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
130 for (int y = 0; y < 500; y += 2) {
131 for (int x = 0; x < 500; x += 2) {
132 pixels[y * 499 + x] = 0xff00ff00;
133 if (x < 498) {
134 pixels[y * 499 + x + 1] = 0xff00ffff;
135 }
136 if (y < 498) {
137 pixels[(y + 1) * 499 + x] = 0xff000000;
138 if (x < 498) {
139 pixels[(y + 1) * 499 + x + 1] = 0xff0000ff;
140 }
141 }
142 }
143 }
144 ImageHalfScaler scaler(&data.front(), 499 * 4, IntSize(499, 499));
146 scaler.ScaleForSize(IntSize(220, 220));
147 VERIFY(scaler.GetSize().width == 249);
148 VERIFY(scaler.GetSize().height == 249);
150 pixels = (uint32_t*)scaler.GetScaledData();
152 for (int y = 0; y < 249; y++) {
153 for (int x = 0; x < 249; x++) {
154 VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f7f);
155 }
156 }
157 }
158 void
159 TestScaling::VerticalHalfScale()
160 {
161 std::vector<uint8_t> data;
162 data.resize(500 * 500 * 4);
164 uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
165 for (int y = 0; y < 500; y += 2) {
166 for (int x = 0; x < 500; x += 2) {
167 pixels[y * 500 + x] = 0xff00ff00;
168 pixels[y * 500 + x + 1] = 0xff00ffff;
169 pixels[(y + 1) * 500 + x] = 0xff000000;
170 pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
171 }
172 }
173 ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(500, 500));
175 scaler.ScaleForSize(IntSize(400, 240));
176 VERIFY(scaler.GetSize().width == 500);
177 VERIFY(scaler.GetSize().height == 250);
179 pixels = (uint32_t*)scaler.GetScaledData();
181 for (int y = 0; y < 250; y++) {
182 for (int x = 0; x < 500; x += 2) {
183 VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff007f00);
184 VERIFY(pixels[y * (scaler.GetStride() / 4) + x + 1] == 0xff007fff);
185 }
186 }
187 }
189 void
190 TestScaling::HorizontalHalfScale()
191 {
192 std::vector<uint8_t> data;
193 data.resize(520 * 500 * 4);
195 uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
196 for (int y = 0; y < 500; y ++) {
197 for (int x = 0; x < 520; x += 8) {
198 pixels[y * 520 + x] = 0xff00ff00;
199 pixels[y * 520 + x + 1] = 0xff00ffff;
200 pixels[y * 520 + x + 2] = 0xff000000;
201 pixels[y * 520 + x + 3] = 0xff0000ff;
202 pixels[y * 520 + x + 4] = 0xffff00ff;
203 pixels[y * 520 + x + 5] = 0xff0000ff;
204 pixels[y * 520 + x + 6] = 0xffffffff;
205 pixels[y * 520 + x + 7] = 0xff0000ff;
206 }
207 }
208 ImageHalfScaler scaler(&data.front(), 520 * 4, IntSize(520, 500));
210 scaler.ScaleForSize(IntSize(240, 400));
211 VERIFY(scaler.GetSize().width == 260);
212 VERIFY(scaler.GetSize().height == 500);
214 pixels = (uint32_t*)scaler.GetScaledData();
216 for (int y = 0; y < 500; y++) {
217 for (int x = 0; x < 260; x += 4) {
218 VERIFY(pixels[y * (scaler.GetStride() / 4) + x] == 0xff00ff7f);
219 VERIFY(pixels[y * (scaler.GetStride() / 4) + x + 1] == 0xff00007f);
220 VERIFY(pixels[y * (scaler.GetStride() / 4) + x + 2] == 0xff7f00ff);
221 VERIFY(pixels[y * (scaler.GetStride() / 4) + x + 3] == 0xff7f7fff);
222 }
223 }
224 }
226 void
227 TestScaling::MixedHalfScale()
228 {
229 std::vector<uint8_t> data;
230 data.resize(500 * 500 * 4);
232 uint32_t *pixels = reinterpret_cast<uint32_t*>(&data.front());
233 for (int y = 0; y < 500; y += 2) {
234 for (int x = 0; x < 500; x += 2) {
235 pixels[y * 500 + x] = 0xff00ff00;
236 pixels[y * 500 + x + 1] = 0xff00ffff;
237 pixels[(y + 1) * 500 + x] = 0xff000000;
238 pixels[(y + 1) * 500 + x + 1] = 0xff0000ff;
239 }
240 }
241 ImageHalfScaler scaler(&data.front(), 500 * 4, IntSize(500, 500));
243 scaler.ScaleForSize(IntSize(120, 240));
244 VERIFY(scaler.GetSize().width == 125);
245 VERIFY(scaler.GetSize().height == 250);
246 scaler.ScaleForSize(IntSize(240, 120));
247 VERIFY(scaler.GetSize().width == 250);
248 VERIFY(scaler.GetSize().height == 125);
249 }
