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