1 /*
2 * Copyright 2017 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "Resources.h"
9 #include "Test.h"
10
11 #include "SkBitmap.h"
12 #include "SkColorPriv.h"
13 #include "SkEncodedImageFormat.h"
14 #include "SkImage.h"
15 #include "SkJpegEncoder.h"
16 #include "SkPngEncoder.h"
17 #include "SkStream.h"
18 #include "SkWebpEncoder.h"
19
20 #include "png.h"
21
22 #include <algorithm>
23 #include <string>
24 #include <vector>
25
26 // FIXME: Update the Google3 build's dependencies so it can run this test.
27 #ifndef SK_BUILD_FOR_GOOGLE3
28 #include "webp/decode.h"
29 #endif
30
encode(SkEncodedImageFormat format,SkWStream * dst,const SkPixmap & src)31 static bool encode(SkEncodedImageFormat format, SkWStream* dst, const SkPixmap& src) {
32 switch (format) {
33 case SkEncodedImageFormat::kJPEG:
34 return SkJpegEncoder::Encode(dst, src, SkJpegEncoder::Options());
35 case SkEncodedImageFormat::kPNG:
36 return SkPngEncoder::Encode(dst, src, SkPngEncoder::Options());
37 default:
38 return false;
39 }
40 }
41
make(SkEncodedImageFormat format,SkWStream * dst,const SkPixmap & src)42 static std::unique_ptr<SkEncoder> make(SkEncodedImageFormat format, SkWStream* dst,
43 const SkPixmap& src) {
44 switch (format) {
45 case SkEncodedImageFormat::kJPEG:
46 return SkJpegEncoder::Make(dst, src, SkJpegEncoder::Options());
47 case SkEncodedImageFormat::kPNG:
48 return SkPngEncoder::Make(dst, src, SkPngEncoder::Options());
49 default:
50 return nullptr;
51 }
52 }
53
test_encode(skiatest::Reporter * r,SkEncodedImageFormat format)54 static void test_encode(skiatest::Reporter* r, SkEncodedImageFormat format) {
55 SkBitmap bitmap;
56 bool success = GetResourceAsBitmap("images/mandrill_128.png", &bitmap);
57 if (!success) {
58 return;
59 }
60
61 SkPixmap src;
62 success = bitmap.peekPixels(&src);
63 REPORTER_ASSERT(r, success);
64 if (!success) {
65 return;
66 }
67
68 SkDynamicMemoryWStream dst0, dst1, dst2, dst3;
69 success = encode(format, &dst0, src);
70 REPORTER_ASSERT(r, success);
71
72 auto encoder1 = make(format, &dst1, src);
73 for (int i = 0; i < src.height(); i++) {
74 success = encoder1->encodeRows(1);
75 REPORTER_ASSERT(r, success);
76 }
77
78 auto encoder2 = make(format, &dst2, src);
79 for (int i = 0; i < src.height(); i+=3) {
80 success = encoder2->encodeRows(3);
81 REPORTER_ASSERT(r, success);
82 }
83
84 auto encoder3 = make(format, &dst3, src);
85 success = encoder3->encodeRows(200);
86 REPORTER_ASSERT(r, success);
87
88 sk_sp<SkData> data0 = dst0.detachAsData();
89 sk_sp<SkData> data1 = dst1.detachAsData();
90 sk_sp<SkData> data2 = dst2.detachAsData();
91 sk_sp<SkData> data3 = dst3.detachAsData();
92 REPORTER_ASSERT(r, data0->equals(data1.get()));
93 REPORTER_ASSERT(r, data0->equals(data2.get()));
94 REPORTER_ASSERT(r, data0->equals(data3.get()));
95 }
96
DEF_TEST(Encode,r)97 DEF_TEST(Encode, r) {
98 test_encode(r, SkEncodedImageFormat::kJPEG);
99 test_encode(r, SkEncodedImageFormat::kPNG);
100 }
101
almost_equals(SkPMColor a,SkPMColor b,int tolerance)102 static inline bool almost_equals(SkPMColor a, SkPMColor b, int tolerance) {
103 if (SkTAbs((int)SkGetPackedR32(a) - (int)SkGetPackedR32(b)) > tolerance) {
104 return false;
105 }
106
107 if (SkTAbs((int)SkGetPackedG32(a) - (int)SkGetPackedG32(b)) > tolerance) {
108 return false;
109 }
110
111 if (SkTAbs((int)SkGetPackedB32(a) - (int)SkGetPackedB32(b)) > tolerance) {
112 return false;
113 }
114
115 if (SkTAbs((int)SkGetPackedA32(a) - (int)SkGetPackedA32(b)) > tolerance) {
116 return false;
117 }
118
119 return true;
120 }
121
almost_equals(const SkBitmap & a,const SkBitmap & b,int tolerance)122 static inline bool almost_equals(const SkBitmap& a, const SkBitmap& b, int tolerance) {
123 if (a.info() != b.info()) {
124 return false;
125 }
126
127 SkASSERT(kN32_SkColorType == a.colorType());
128 for (int y = 0; y < a.height(); y++) {
129 for (int x = 0; x < a.width(); x++) {
130 if (!almost_equals(*a.getAddr32(x, y), *b.getAddr32(x, y), tolerance)) {
131 return false;
132 }
133 }
134 }
135
136 return true;
137 }
138
DEF_TEST(Encode_JpegDownsample,r)139 DEF_TEST(Encode_JpegDownsample, r) {
140 SkBitmap bitmap;
141 bool success = GetResourceAsBitmap("images/mandrill_128.png", &bitmap);
142 if (!success) {
143 return;
144 }
145
146 SkPixmap src;
147 success = bitmap.peekPixels(&src);
148 REPORTER_ASSERT(r, success);
149 if (!success) {
150 return;
151 }
152
153 SkDynamicMemoryWStream dst0, dst1, dst2;
154 SkJpegEncoder::Options options;
155 success = SkJpegEncoder::Encode(&dst0, src, options);
156 REPORTER_ASSERT(r, success);
157
158 options.fDownsample = SkJpegEncoder::Downsample::k422;
159 success = SkJpegEncoder::Encode(&dst1, src, options);
160 REPORTER_ASSERT(r, success);
161
162 options.fDownsample = SkJpegEncoder::Downsample::k444;
163 success = SkJpegEncoder::Encode(&dst2, src, options);
164 REPORTER_ASSERT(r, success);
165
166 sk_sp<SkData> data0 = dst0.detachAsData();
167 sk_sp<SkData> data1 = dst1.detachAsData();
168 sk_sp<SkData> data2 = dst2.detachAsData();
169 REPORTER_ASSERT(r, data0->size() < data1->size());
170 REPORTER_ASSERT(r, data1->size() < data2->size());
171
172 SkBitmap bm0, bm1, bm2;
173 SkImage::MakeFromEncoded(data0)->asLegacyBitmap(&bm0);
174 SkImage::MakeFromEncoded(data1)->asLegacyBitmap(&bm1);
175 SkImage::MakeFromEncoded(data2)->asLegacyBitmap(&bm2);
176 REPORTER_ASSERT(r, almost_equals(bm0, bm1, 60));
177 REPORTER_ASSERT(r, almost_equals(bm1, bm2, 60));
178 }
179
pushComment(std::vector<std::string> & comments,const char * keyword,const char * text)180 static inline void pushComment(
181 std::vector<std::string>& comments, const char* keyword, const char* text) {
182 comments.push_back(keyword);
183 comments.push_back(text);
184 }
185
testPngComments(const SkPixmap & src,SkPngEncoder::Options & options,skiatest::Reporter * r)186 static void testPngComments(const SkPixmap& src, SkPngEncoder::Options& options,
187 skiatest::Reporter* r) {
188 std::vector<std::string> commentStrings;
189 pushComment(commentStrings, "key", "text");
190 pushComment(commentStrings, "test", "something");
191 pushComment(commentStrings, "have some", "spaces in both");
192
193 std::string longKey(PNG_KEYWORD_MAX_LENGTH, 'x');
194 #ifdef SK_DEBUG
195 commentStrings.push_back(longKey);
196 #else
197 // We call SkDEBUGFAILF it the key is too long so we'll only test this in release mode.
198 commentStrings.push_back(longKey + "x");
199 #endif
200 commentStrings.push_back("");
201
202 std::vector<const char*> commentPointers;
203 std::vector<size_t> commentSizes;
204 for(auto& str : commentStrings) {
205 commentPointers.push_back(str.c_str());
206 commentSizes.push_back(str.length() + 1);
207 }
208
209 options.fComments = SkDataTable::MakeCopyArrays((void const *const *)commentPointers.data(),
210 commentSizes.data(), commentStrings.size());
211
212
213 SkDynamicMemoryWStream dst;
214 bool success = SkPngEncoder::Encode(&dst, src, options);
215 REPORTER_ASSERT(r, success);
216
217 std::vector<char> output(dst.bytesWritten());
218 dst.copyTo(output.data());
219
220 // Each chunk is of the form length (4 bytes), chunk type (tEXt), data,
221 // checksum (4 bytes). Make sure we find all of them in the encoded
222 // results.
223 const char kExpected1[] =
224 "\x00\x00\x00\x08tEXtkey\x00text\x9e\xe7\x66\x51";
225 const char kExpected2[] =
226 "\x00\x00\x00\x0etEXttest\x00something\x29\xba\xef\xac";
227 const char kExpected3[] =
228 "\x00\x00\x00\x18tEXthave some\x00spaces in both\x8d\x69\x34\x2d";
229 std::string longKeyRecord = "tEXt" + longKey; // A snippet of our long key comment
230 std::string tooLongRecord = "tExt" + longKey + "x"; // A snippet whose key is too long
231
232 auto search1 = std::search(output.begin(), output.end(),
233 kExpected1, kExpected1 + sizeof(kExpected1));
234 auto search2 = std::search(output.begin(), output.end(),
235 kExpected2, kExpected2 + sizeof(kExpected2));
236 auto search3 = std::search(output.begin(), output.end(),
237 kExpected3, kExpected3 + sizeof(kExpected3));
238 auto search4 = std::search(output.begin(), output.end(),
239 longKeyRecord.begin(), longKeyRecord.end());
240 auto search5 = std::search(output.begin(), output.end(),
241 tooLongRecord.begin(), tooLongRecord.end());
242
243 REPORTER_ASSERT(r, search1 != output.end());
244 REPORTER_ASSERT(r, search2 != output.end());
245 REPORTER_ASSERT(r, search3 != output.end());
246 REPORTER_ASSERT(r, search4 != output.end());
247 REPORTER_ASSERT(r, search5 == output.end());
248 // Comments test ends
249 }
250
DEF_TEST(Encode_PngOptions,r)251 DEF_TEST(Encode_PngOptions, r) {
252 SkBitmap bitmap;
253 bool success = GetResourceAsBitmap("images/mandrill_128.png", &bitmap);
254 if (!success) {
255 return;
256 }
257
258 SkPixmap src;
259 success = bitmap.peekPixels(&src);
260 REPORTER_ASSERT(r, success);
261 if (!success) {
262 return;
263 }
264
265 SkDynamicMemoryWStream dst0, dst1, dst2;
266 SkPngEncoder::Options options;
267 success = SkPngEncoder::Encode(&dst0, src, options);
268 REPORTER_ASSERT(r, success);
269
270 options.fFilterFlags = SkPngEncoder::FilterFlag::kUp;
271 success = SkPngEncoder::Encode(&dst1, src, options);
272 REPORTER_ASSERT(r, success);
273
274 options.fZLibLevel = 3;
275 success = SkPngEncoder::Encode(&dst2, src, options);
276 REPORTER_ASSERT(r, success);
277
278 testPngComments(src, options, r);
279
280 sk_sp<SkData> data0 = dst0.detachAsData();
281 sk_sp<SkData> data1 = dst1.detachAsData();
282 sk_sp<SkData> data2 = dst2.detachAsData();
283 REPORTER_ASSERT(r, data0->size() < data1->size());
284 REPORTER_ASSERT(r, data1->size() < data2->size());
285
286 SkBitmap bm0, bm1, bm2;
287 SkImage::MakeFromEncoded(data0)->asLegacyBitmap(&bm0);
288 SkImage::MakeFromEncoded(data1)->asLegacyBitmap(&bm1);
289 SkImage::MakeFromEncoded(data2)->asLegacyBitmap(&bm2);
290 REPORTER_ASSERT(r, almost_equals(bm0, bm1, 0));
291 REPORTER_ASSERT(r, almost_equals(bm0, bm2, 0));
292 }
293
294 #ifndef SK_BUILD_FOR_GOOGLE3
DEF_TEST(Encode_WebpQuality,r)295 DEF_TEST(Encode_WebpQuality, r) {
296 SkBitmap bm;
297 bm.allocN32Pixels(100, 100);
298 bm.eraseColor(SK_ColorBLUE);
299
300 auto dataLossy = SkEncodeBitmap(bm, SkEncodedImageFormat::kWEBP, 99);
301 auto dataLossLess = SkEncodeBitmap(bm, SkEncodedImageFormat::kWEBP, 100);
302
303 enum Format {
304 kMixed = 0,
305 kLossy = 1,
306 kLossless = 2,
307 };
308
309 auto test = [&r](const sk_sp<SkData>& data, Format expected) {
310 auto printFormat = [](int f) {
311 switch (f) {
312 case kMixed: return "mixed";
313 case kLossy: return "lossy";
314 case kLossless: return "lossless";
315 default: return "unknown";
316 }
317 };
318
319 if (!data) {
320 ERRORF(r, "Failed to encode. Expected %s", printFormat(expected));
321 return;
322 }
323
324 WebPBitstreamFeatures features;
325 auto status = WebPGetFeatures(data->bytes(), data->size(), &features);
326 if (status != VP8_STATUS_OK) {
327 ERRORF(r, "Encode had an error %i. Expected %s", status, printFormat(expected));
328 return;
329 }
330
331 if (expected != features.format) {
332 ERRORF(r, "Expected %s encode, but got format %s", printFormat(expected),
333 printFormat(features.format));
334 }
335 };
336
337 test(dataLossy, kLossy);
338 test(dataLossLess, kLossless);
339 }
340 #endif
341
DEF_TEST(Encode_WebpOptions,r)342 DEF_TEST(Encode_WebpOptions, r) {
343 SkBitmap bitmap;
344 bool success = GetResourceAsBitmap("images/google_chrome.ico", &bitmap);
345 if (!success) {
346 return;
347 }
348
349 SkPixmap src;
350 success = bitmap.peekPixels(&src);
351 REPORTER_ASSERT(r, success);
352 if (!success) {
353 return;
354 }
355
356 SkDynamicMemoryWStream dst0, dst1, dst2, dst3;
357 SkWebpEncoder::Options options;
358 options.fCompression = SkWebpEncoder::Compression::kLossless;
359 options.fQuality = 0.0f;
360 success = SkWebpEncoder::Encode(&dst0, src, options);
361 REPORTER_ASSERT(r, success);
362
363 options.fQuality = 100.0f;
364 success = SkWebpEncoder::Encode(&dst1, src, options);
365 REPORTER_ASSERT(r, success);
366
367 options.fCompression = SkWebpEncoder::Compression::kLossy;
368 options.fQuality = 100.0f;
369 success = SkWebpEncoder::Encode(&dst2, src, options);
370 REPORTER_ASSERT(r, success);
371
372 options.fCompression = SkWebpEncoder::Compression::kLossy;
373 options.fQuality = 50.0f;
374 success = SkWebpEncoder::Encode(&dst3, src, options);
375 REPORTER_ASSERT(r, success);
376
377 sk_sp<SkData> data0 = dst0.detachAsData();
378 sk_sp<SkData> data1 = dst1.detachAsData();
379 sk_sp<SkData> data2 = dst2.detachAsData();
380 sk_sp<SkData> data3 = dst3.detachAsData();
381 REPORTER_ASSERT(r, data0->size() > data1->size());
382 REPORTER_ASSERT(r, data1->size() > data2->size());
383 REPORTER_ASSERT(r, data2->size() > data3->size());
384
385 SkBitmap bm0, bm1, bm2, bm3;
386 SkImage::MakeFromEncoded(data0)->asLegacyBitmap(&bm0);
387 SkImage::MakeFromEncoded(data1)->asLegacyBitmap(&bm1);
388 SkImage::MakeFromEncoded(data2)->asLegacyBitmap(&bm2);
389 SkImage::MakeFromEncoded(data3)->asLegacyBitmap(&bm3);
390 REPORTER_ASSERT(r, almost_equals(bm0, bm1, 0));
391 REPORTER_ASSERT(r, almost_equals(bm0, bm2, 90));
392 REPORTER_ASSERT(r, almost_equals(bm2, bm3, 50));
393 }
394
