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 "include/codec/SkCodec.h"
9 #include "include/core/SkAlphaType.h"
10 #include "include/core/SkBitmap.h"
11 #include "include/core/SkCanvas.h"
12 #include "include/core/SkColor.h"
13 #include "include/core/SkColorPriv.h"
14 #include "include/core/SkColorType.h"
15 #include "include/core/SkData.h"
16 #include "include/core/SkDataTable.h"
17 #include "include/core/SkEncodedImageFormat.h"
18 #include "include/core/SkImage.h"
19 #include "include/core/SkImageEncoder.h"
20 #include "include/core/SkImageInfo.h"
21 #include "include/core/SkPixmap.h"
22 #include "include/core/SkRefCnt.h"
23 #include "include/core/SkStream.h"
24 #include "include/core/SkSurface.h"
25 #include "include/core/SkTypes.h"
26 #include "include/encode/SkEncoder.h"
27 #include "include/encode/SkJpegEncoder.h"
28 #include "include/encode/SkPngEncoder.h"
29 #include "include/encode/SkWebpEncoder.h"
30 #include "include/private/base/SkTemplates.h"
31 #include "include/private/base/SkMalloc.h"
32 #include "src/core/SkImageInfoPriv.h"
33 #include "tests/Test.h"
34 #include "tools/Resources.h"
35
36 #include <png.h>
37 #include <webp/decode.h>
38
39 #include <algorithm>
40 #include <cstddef>
41 #include <initializer_list>
42 #include <memory>
43 #include <string>
44 #include <vector>
45
encode(SkEncodedImageFormat format,SkWStream * dst,const SkPixmap & src)46 static bool encode(SkEncodedImageFormat format, SkWStream* dst, const SkPixmap& src) {
47 switch (format) {
48 case SkEncodedImageFormat::kJPEG:
49 return SkJpegEncoder::Encode(dst, src, SkJpegEncoder::Options());
50 case SkEncodedImageFormat::kPNG:
51 return SkPngEncoder::Encode(dst, src, SkPngEncoder::Options());
52 default:
53 return false;
54 }
55 }
56
make(SkEncodedImageFormat format,SkWStream * dst,const SkPixmap & src)57 static std::unique_ptr<SkEncoder> make(SkEncodedImageFormat format, SkWStream* dst,
58 const SkPixmap& src) {
59 switch (format) {
60 case SkEncodedImageFormat::kJPEG:
61 return SkJpegEncoder::Make(dst, src, SkJpegEncoder::Options());
62 case SkEncodedImageFormat::kPNG:
63 return SkPngEncoder::Make(dst, src, SkPngEncoder::Options());
64 default:
65 return nullptr;
66 }
67 }
68
test_encode(skiatest::Reporter * r,SkEncodedImageFormat format)69 static void test_encode(skiatest::Reporter* r, SkEncodedImageFormat format) {
70 SkBitmap bitmap;
71 bool success = GetResourceAsBitmap("images/mandrill_128.png", &bitmap);
72 if (!success) {
73 return;
74 }
75
76 SkPixmap src;
77 success = bitmap.peekPixels(&src);
78 REPORTER_ASSERT(r, success);
79 if (!success) {
80 return;
81 }
82
83 SkDynamicMemoryWStream dst0, dst1, dst2, dst3;
84 success = encode(format, &dst0, src);
85 REPORTER_ASSERT(r, success);
86
87 auto encoder1 = make(format, &dst1, src);
88 for (int i = 0; i < src.height(); i++) {
89 success = encoder1->encodeRows(1);
90 REPORTER_ASSERT(r, success);
91 }
92
93 auto encoder2 = make(format, &dst2, src);
94 for (int i = 0; i < src.height(); i+=3) {
95 success = encoder2->encodeRows(3);
96 REPORTER_ASSERT(r, success);
97 }
98
99 auto encoder3 = make(format, &dst3, src);
100 success = encoder3->encodeRows(200);
101 REPORTER_ASSERT(r, success);
102
103 sk_sp<SkData> data0 = dst0.detachAsData();
104 sk_sp<SkData> data1 = dst1.detachAsData();
105 sk_sp<SkData> data2 = dst2.detachAsData();
106 sk_sp<SkData> data3 = dst3.detachAsData();
107 REPORTER_ASSERT(r, data0->equals(data1.get()));
108 REPORTER_ASSERT(r, data0->equals(data2.get()));
109 REPORTER_ASSERT(r, data0->equals(data3.get()));
110 }
111
DEF_TEST(Encode,r)112 DEF_TEST(Encode, r) {
113 test_encode(r, SkEncodedImageFormat::kJPEG);
114 test_encode(r, SkEncodedImageFormat::kPNG);
115 }
116
almost_equals(SkPMColor a,SkPMColor b,int tolerance)117 static inline bool almost_equals(SkPMColor a, SkPMColor b, int tolerance) {
118 if (SkTAbs((int)SkGetPackedR32(a) - (int)SkGetPackedR32(b)) > tolerance) {
119 return false;
120 }
121
122 if (SkTAbs((int)SkGetPackedG32(a) - (int)SkGetPackedG32(b)) > tolerance) {
123 return false;
124 }
125
126 if (SkTAbs((int)SkGetPackedB32(a) - (int)SkGetPackedB32(b)) > tolerance) {
127 return false;
128 }
129
130 if (SkTAbs((int)SkGetPackedA32(a) - (int)SkGetPackedA32(b)) > tolerance) {
131 return false;
132 }
133
134 return true;
135 }
136
almost_equals(const SkBitmap & a,const SkBitmap & b,int tolerance)137 static inline bool almost_equals(const SkBitmap& a, const SkBitmap& b, int tolerance) {
138 if (a.info() != b.info()) {
139 return false;
140 }
141
142 SkASSERT(kN32_SkColorType == a.colorType());
143 for (int y = 0; y < a.height(); y++) {
144 for (int x = 0; x < a.width(); x++) {
145 if (!almost_equals(*a.getAddr32(x, y), *b.getAddr32(x, y), tolerance)) {
146 return false;
147 }
148 }
149 }
150
151 return true;
152 }
153
DEF_TEST(Encode_JPG,r)154 DEF_TEST(Encode_JPG, r) {
155 auto image = GetResourceAsImage("images/mandrill_128.png");
156 if (!image) {
157 return;
158 }
159
160 for (auto ct : { kRGBA_8888_SkColorType,
161 kBGRA_8888_SkColorType,
162 kRGB_565_SkColorType,
163 kARGB_4444_SkColorType,
164 kGray_8_SkColorType,
165 kRGBA_F16_SkColorType }) {
166 for (auto at : { kPremul_SkAlphaType, kUnpremul_SkAlphaType, kOpaque_SkAlphaType }) {
167 auto info = SkImageInfo::Make(image->width(), image->height(), ct, at);
168 auto surface = SkSurface::MakeRaster(info);
169 auto canvas = surface->getCanvas();
170 canvas->drawImage(image, 0, 0);
171
172 SkBitmap bm;
173 bm.allocPixels(info);
174 if (!surface->makeImageSnapshot()->readPixels(nullptr, bm.pixmap(), 0, 0)) {
175 ERRORF(r, "failed to readPixels! ct: %i\tat: %i\n", ct, at);
176 continue;
177 }
178 for (auto alphaOption : { SkJpegEncoder::AlphaOption::kIgnore,
179 SkJpegEncoder::AlphaOption::kBlendOnBlack }) {
180 SkJpegEncoder::Options opts;
181 opts.fAlphaOption = alphaOption;
182 SkNullWStream ignored;
183 if (!SkJpegEncoder::Encode(&ignored, bm.pixmap(), opts)) {
184 REPORTER_ASSERT(r, ct == kARGB_4444_SkColorType
185 && alphaOption == SkJpegEncoder::AlphaOption::kBlendOnBlack);
186 }
187 }
188 }
189 }
190 }
191
DEF_TEST(Encode_JpegDownsample,r)192 DEF_TEST(Encode_JpegDownsample, r) {
193 SkBitmap bitmap;
194 bool success = GetResourceAsBitmap("images/mandrill_128.png", &bitmap);
195 if (!success) {
196 return;
197 }
198
199 SkPixmap src;
200 success = bitmap.peekPixels(&src);
201 REPORTER_ASSERT(r, success);
202 if (!success) {
203 return;
204 }
205
206 SkDynamicMemoryWStream dst0, dst1, dst2;
207 SkJpegEncoder::Options options;
208 success = SkJpegEncoder::Encode(&dst0, src, options);
209 REPORTER_ASSERT(r, success);
210
211 options.fDownsample = SkJpegEncoder::Downsample::k422;
212 success = SkJpegEncoder::Encode(&dst1, src, options);
213 REPORTER_ASSERT(r, success);
214
215 options.fDownsample = SkJpegEncoder::Downsample::k444;
216 success = SkJpegEncoder::Encode(&dst2, src, options);
217 REPORTER_ASSERT(r, success);
218
219 sk_sp<SkData> data0 = dst0.detachAsData();
220 sk_sp<SkData> data1 = dst1.detachAsData();
221 sk_sp<SkData> data2 = dst2.detachAsData();
222 REPORTER_ASSERT(r, data0->size() < data1->size());
223 REPORTER_ASSERT(r, data1->size() < data2->size());
224
225 SkBitmap bm0, bm1, bm2;
226 SkImage::MakeFromEncoded(data0)->asLegacyBitmap(&bm0);
227 SkImage::MakeFromEncoded(data1)->asLegacyBitmap(&bm1);
228 SkImage::MakeFromEncoded(data2)->asLegacyBitmap(&bm2);
229 REPORTER_ASSERT(r, almost_equals(bm0, bm1, 60));
230 REPORTER_ASSERT(r, almost_equals(bm1, bm2, 60));
231 }
232
pushComment(std::vector<std::string> & comments,const char * keyword,const char * text)233 static inline void pushComment(
234 std::vector<std::string>& comments, const char* keyword, const char* text) {
235 comments.push_back(keyword);
236 comments.push_back(text);
237 }
238
testPngComments(const SkPixmap & src,SkPngEncoder::Options & options,skiatest::Reporter * r)239 static void testPngComments(const SkPixmap& src, SkPngEncoder::Options& options,
240 skiatest::Reporter* r) {
241 std::vector<std::string> commentStrings;
242 pushComment(commentStrings, "key", "text");
243 pushComment(commentStrings, "test", "something");
244 pushComment(commentStrings, "have some", "spaces in both");
245
246 std::string longKey(PNG_KEYWORD_MAX_LENGTH, 'x');
247 #ifdef SK_DEBUG
248 commentStrings.push_back(longKey);
249 #else
250 // We call SkDEBUGFAILF it the key is too long so we'll only test this in release mode.
251 commentStrings.push_back(longKey + "x");
252 #endif
253 commentStrings.push_back("");
254
255 std::vector<const char*> commentPointers;
256 std::vector<size_t> commentSizes;
257 for(auto& str : commentStrings) {
258 commentPointers.push_back(str.c_str());
259 commentSizes.push_back(str.length() + 1);
260 }
261
262 options.fComments = SkDataTable::MakeCopyArrays((void const *const *)commentPointers.data(),
263 commentSizes.data(), commentStrings.size());
264
265
266 SkDynamicMemoryWStream dst;
267 bool success = SkPngEncoder::Encode(&dst, src, options);
268 REPORTER_ASSERT(r, success);
269
270 std::vector<char> output(dst.bytesWritten());
271 dst.copyTo(output.data());
272
273 // Each chunk is of the form length (4 bytes), chunk type (tEXt), data,
274 // checksum (4 bytes). Make sure we find all of them in the encoded
275 // results.
276 const char kExpected1[] =
277 "\x00\x00\x00\x08tEXtkey\x00text\x9e\xe7\x66\x51";
278 const char kExpected2[] =
279 "\x00\x00\x00\x0etEXttest\x00something\x29\xba\xef\xac";
280 const char kExpected3[] =
281 "\x00\x00\x00\x18tEXthave some\x00spaces in both\x8d\x69\x34\x2d";
282 std::string longKeyRecord = "tEXt" + longKey; // A snippet of our long key comment
283 std::string tooLongRecord = "tExt" + longKey + "x"; // A snippet whose key is too long
284
285 auto search1 = std::search(output.begin(), output.end(),
286 kExpected1, kExpected1 + sizeof(kExpected1));
287 auto search2 = std::search(output.begin(), output.end(),
288 kExpected2, kExpected2 + sizeof(kExpected2));
289 auto search3 = std::search(output.begin(), output.end(),
290 kExpected3, kExpected3 + sizeof(kExpected3));
291 auto search4 = std::search(output.begin(), output.end(),
292 longKeyRecord.begin(), longKeyRecord.end());
293 auto search5 = std::search(output.begin(), output.end(),
294 tooLongRecord.begin(), tooLongRecord.end());
295
296 REPORTER_ASSERT(r, search1 != output.end());
297 REPORTER_ASSERT(r, search2 != output.end());
298 REPORTER_ASSERT(r, search3 != output.end());
299 REPORTER_ASSERT(r, search4 != output.end());
300 REPORTER_ASSERT(r, search5 == output.end());
301 // Comments test ends
302 }
303
DEF_TEST(Encode_PngOptions,r)304 DEF_TEST(Encode_PngOptions, r) {
305 SkBitmap bitmap;
306 bool success = GetResourceAsBitmap("images/mandrill_128.png", &bitmap);
307 if (!success) {
308 return;
309 }
310
311 SkPixmap src;
312 success = bitmap.peekPixels(&src);
313 REPORTER_ASSERT(r, success);
314 if (!success) {
315 return;
316 }
317
318 SkDynamicMemoryWStream dst0, dst1, dst2;
319 SkPngEncoder::Options options;
320 success = SkPngEncoder::Encode(&dst0, src, options);
321 REPORTER_ASSERT(r, success);
322
323 options.fFilterFlags = SkPngEncoder::FilterFlag::kUp;
324 success = SkPngEncoder::Encode(&dst1, src, options);
325 REPORTER_ASSERT(r, success);
326
327 options.fZLibLevel = 3;
328 success = SkPngEncoder::Encode(&dst2, src, options);
329 REPORTER_ASSERT(r, success);
330
331 testPngComments(src, options, r);
332
333 sk_sp<SkData> data0 = dst0.detachAsData();
334 sk_sp<SkData> data1 = dst1.detachAsData();
335 sk_sp<SkData> data2 = dst2.detachAsData();
336 REPORTER_ASSERT(r, data0->size() < data1->size());
337 REPORTER_ASSERT(r, data1->size() < data2->size());
338
339 SkBitmap bm0, bm1, bm2;
340 SkImage::MakeFromEncoded(data0)->asLegacyBitmap(&bm0);
341 SkImage::MakeFromEncoded(data1)->asLegacyBitmap(&bm1);
342 SkImage::MakeFromEncoded(data2)->asLegacyBitmap(&bm2);
343 REPORTER_ASSERT(r, almost_equals(bm0, bm1, 0));
344 REPORTER_ASSERT(r, almost_equals(bm0, bm2, 0));
345 }
346
347 #ifndef SK_BUILD_FOR_GOOGLE3
DEF_TEST(Encode_WebpQuality,r)348 DEF_TEST(Encode_WebpQuality, r) {
349 SkBitmap bm;
350 bm.allocN32Pixels(100, 100);
351 bm.eraseColor(SK_ColorBLUE);
352
353 auto dataLossy = SkEncodeBitmap(bm, SkEncodedImageFormat::kWEBP, 99);
354 auto dataLossLess = SkEncodeBitmap(bm, SkEncodedImageFormat::kWEBP, 100);
355
356 enum Format {
357 kMixed = 0,
358 kLossy = 1,
359 kLossless = 2,
360 };
361
362 auto test = [&r](const sk_sp<SkData>& data, Format expected) {
363 auto printFormat = [](int f) {
364 switch (f) {
365 case kMixed: return "mixed";
366 case kLossy: return "lossy";
367 case kLossless: return "lossless";
368 default: return "unknown";
369 }
370 };
371
372 if (!data) {
373 ERRORF(r, "Failed to encode. Expected %s", printFormat(expected));
374 return;
375 }
376
377 WebPBitstreamFeatures features;
378 auto status = WebPGetFeatures(data->bytes(), data->size(), &features);
379 if (status != VP8_STATUS_OK) {
380 ERRORF(r, "Encode had an error %i. Expected %s", status, printFormat(expected));
381 return;
382 }
383
384 if (expected != features.format) {
385 ERRORF(r, "Expected %s encode, but got format %s", printFormat(expected),
386 printFormat(features.format));
387 }
388 };
389
390 test(dataLossy, kLossy);
391 test(dataLossLess, kLossless);
392 }
393 #endif
394
DEF_TEST(Encode_WebpOptions,r)395 DEF_TEST(Encode_WebpOptions, r) {
396 SkBitmap bitmap;
397 bool success = GetResourceAsBitmap("images/google_chrome.ico", &bitmap);
398 if (!success) {
399 return;
400 }
401
402 SkPixmap src;
403 success = bitmap.peekPixels(&src);
404 REPORTER_ASSERT(r, success);
405 if (!success) {
406 return;
407 }
408
409 SkDynamicMemoryWStream dst0, dst1, dst2, dst3;
410 SkWebpEncoder::Options options;
411 options.fCompression = SkWebpEncoder::Compression::kLossless;
412 options.fQuality = 0.0f;
413 success = SkWebpEncoder::Encode(&dst0, src, options);
414 REPORTER_ASSERT(r, success);
415
416 options.fQuality = 100.0f;
417 success = SkWebpEncoder::Encode(&dst1, src, options);
418 REPORTER_ASSERT(r, success);
419
420 options.fCompression = SkWebpEncoder::Compression::kLossy;
421 options.fQuality = 100.0f;
422 success = SkWebpEncoder::Encode(&dst2, src, options);
423 REPORTER_ASSERT(r, success);
424
425 options.fCompression = SkWebpEncoder::Compression::kLossy;
426 options.fQuality = 50.0f;
427 success = SkWebpEncoder::Encode(&dst3, src, options);
428 REPORTER_ASSERT(r, success);
429
430 sk_sp<SkData> data0 = dst0.detachAsData();
431 sk_sp<SkData> data1 = dst1.detachAsData();
432 sk_sp<SkData> data2 = dst2.detachAsData();
433 sk_sp<SkData> data3 = dst3.detachAsData();
434 REPORTER_ASSERT(r, data0->size() > data1->size());
435 REPORTER_ASSERT(r, data1->size() > data2->size());
436 REPORTER_ASSERT(r, data2->size() > data3->size());
437
438 SkBitmap bm0, bm1, bm2, bm3;
439 SkImage::MakeFromEncoded(data0)->asLegacyBitmap(&bm0);
440 SkImage::MakeFromEncoded(data1)->asLegacyBitmap(&bm1);
441 SkImage::MakeFromEncoded(data2)->asLegacyBitmap(&bm2);
442 SkImage::MakeFromEncoded(data3)->asLegacyBitmap(&bm3);
443 REPORTER_ASSERT(r, almost_equals(bm0, bm1, 0));
444 REPORTER_ASSERT(r, almost_equals(bm0, bm2, 90));
445 REPORTER_ASSERT(r, almost_equals(bm2, bm3, 50));
446 }
447
DEF_TEST(Encode_WebpAnimated,r)448 DEF_TEST(Encode_WebpAnimated, r) {
449 const int frameCount = 3;
450 const int width = 16;
451 const int height = 16;
452 auto info = SkImageInfo::MakeN32Premul(width, height);
453 std::vector<SkBitmap> bitmaps(frameCount);
454 std::vector<SkEncoder::Frame> frames(frameCount);
455 std::vector<int> durations = {50, 100, 150};
456 std::vector<SkColor> colors = {SK_ColorRED, SK_ColorBLUE, SK_ColorGREEN};
457
458 for (int i = 0; i < frameCount; i++) {
459 bitmaps[i].allocPixels(info);
460 bitmaps[i].eraseColor(colors[i]);
461 REPORTER_ASSERT(r, bitmaps[i].peekPixels(&frames[i].pixmap));
462 frames[i].duration = durations[i];
463 }
464
465 SkDynamicMemoryWStream stream;
466 SkWebpEncoder::Options options;
467 options.fCompression = SkWebpEncoder::Compression::kLossless;
468 options.fQuality = 100;
469
470 REPORTER_ASSERT(r, SkWebpEncoder::EncodeAnimated(&stream, frames, options));
471
472 auto codec = SkCodec::MakeFromData(stream.detachAsData());
473 REPORTER_ASSERT(r, !!codec);
474
475 std::vector<SkCodec::FrameInfo> frameInfos = codec->getFrameInfo();
476 REPORTER_ASSERT(r, frameInfos.size() == frameCount);
477
478 for (size_t i = 0; i < frameInfos.size(); ++i) {
479 SkBitmap bitmap;
480 bitmap.allocPixels(info);
481 bitmap.eraseColor(0);
482
483 SkCodec::Options codecOptions;
484 codecOptions.fFrameIndex = (int)i;
485
486 auto result = codec->getPixels(info, bitmap.getPixels(), bitmap.rowBytes(), &codecOptions);
487 if (result != SkCodec::kSuccess) {
488 ERRORF(r, "error in frame %zu: %s", i, SkCodec::ResultToString(result));
489 }
490
491 REPORTER_ASSERT(r, almost_equals(bitmap, bitmaps[i], 0));
492 REPORTER_ASSERT(r, frameInfos[i].fDuration == durations[i]);
493 }
494 }
495
DEF_TEST(Encode_WebpAnimated_FrameUnmatched,r)496 DEF_TEST(Encode_WebpAnimated_FrameUnmatched, r) {
497 // Create two frames with unmatched sizes and verify the encode should fail.
498 SkEncoder::Frame frame1;
499 SkBitmap bm1;
500 bm1.allocPixels(SkImageInfo::MakeN32Premul(8, 8));
501 bm1.eraseColor(SK_ColorYELLOW);
502 REPORTER_ASSERT(r, bm1.peekPixels(&frame1.pixmap));
503 frame1.duration = 200;
504
505 SkEncoder::Frame frame2;
506 SkBitmap bm2;
507 bm2.allocPixels(SkImageInfo::MakeN32Premul(16, 16));
508 bm2.eraseColor(SK_ColorYELLOW);
509 REPORTER_ASSERT(r, bm2.peekPixels(&frame2.pixmap));
510 frame2.duration = 200;
511
512 SkDynamicMemoryWStream stream;
513 SkWebpEncoder::Options options;
514 options.fCompression = SkWebpEncoder::Compression::kLossy;
515 options.fQuality = 100;
516 std::vector<SkEncoder::Frame> frames = {frame1, frame2};
517 bool output = SkWebpEncoder::EncodeAnimated(&stream, frames, options);
518 REPORTER_ASSERT(r, !output);
519 }
520
DEF_TEST(Encode_Alpha,r)521 DEF_TEST(Encode_Alpha, r) {
522 // These formats have no sensible way to encode alpha images.
523 for (auto format : { SkEncodedImageFormat::kJPEG,
524 SkEncodedImageFormat::kPNG,
525 SkEncodedImageFormat::kWEBP }) {
526 for (int ctAsInt = kUnknown_SkColorType + 1; ctAsInt <= kLastEnum_SkColorType; ctAsInt++) {
527 auto ct = static_cast<SkColorType>(ctAsInt);
528 // Non-alpha-only colortypes are tested elsewhere.
529 if (!SkColorTypeIsAlphaOnly(ct)) continue;
530 SkBitmap bm;
531 bm.allocPixels(SkImageInfo::Make(10, 10, ct, kPremul_SkAlphaType));
532 sk_bzero(bm.getPixels(), bm.computeByteSize());
533 auto data = SkEncodeBitmap(bm, format, 100);
534 if ((format == SkEncodedImageFormat::kJPEG || format == SkEncodedImageFormat::kPNG) &&
535 ct == kAlpha_8_SkColorType) {
536 // We support encoding alpha8 to png and jpeg with our own private meaning.
537 REPORTER_ASSERT(r, data != nullptr);
538 } else {
539 REPORTER_ASSERT(r, data == nullptr);
540 }
541 }
542 }
543 }
544
