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