static void TestPictureTypefaceSerialization(skiatest::Reporter* reporter) { { // Load typeface from file to test CreateFromFile with index. auto data = GetResourceAsData("fonts/test.ttc"); auto typeface = SkTypeface::MakeFromStream(new SkMemoryStream(std::move(data)), 1); if (!typeface) { INFOF(reporter, "Could not run fontstream test because test.ttc not found."); } else { serialize_and_compare_typeface(std::move(typeface), "A!", reporter); } } { // Load typeface as stream to create with axis settings. std::unique_ptr<SkStreamAsset> distortable(GetResourceAsStream("fonts/Distortable.ttf")); if (!distortable) { INFOF(reporter, "Could not run fontstream test because Distortable.ttf not found."); } else { SkFixed axis = SK_FixedSqrt2; sk_sp<SkTypeface> typeface(SkTypeface::MakeFromFontData( skstd::make_unique<SkFontData>(std::move(distortable), 0, &axis, 1))); if (!typeface) { INFOF(reporter, "Could not run fontstream test because Distortable.ttf not created."); } else { serialize_and_compare_typeface(std::move(typeface), "abc", reporter); } } } }
DEF_TEST(ColorSpace_Serialize, r) { test_serialize(r, SkColorSpace::MakeSRGB(), true); test_serialize(r, SkColorSpace::MakeSRGBLinear(), true); auto test = [&](const char* path) { sk_sp<SkData> data = GetResourceAsData(path); skcms_ICCProfile profile; REPORTER_ASSERT(r, skcms_Parse(data->data(), data->size(), &profile)); sk_sp<SkColorSpace> space = SkColorSpace::Make(profile); REPORTER_ASSERT(r, space); test_serialize(r, space, false); }; test("icc_profiles/HP_ZR30w.icc"); test("icc_profiles/HP_Z32x.icc"); skcms_TransferFunction fn; fn.a = 1.0f; fn.b = 0.0f; fn.c = 1.0f; fn.d = 0.5f; fn.e = 0.0f; fn.f = 0.0f; fn.g = 1.0f; skcms_Matrix3x3 toXYZ = {{ { 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 }, }}; test_serialize(r, SkColorSpace::MakeRGB(fn, toXYZ), false); }
DEF_TEST(Codec_trunc, r) { sk_sp<SkData> data(GetResourceAsData("images/box.gif")); if (!data) { return; } SkCodec::MakeFromData(SkData::MakeSubset(data.get(), 0, 23))->getFrameInfo(); }
DEF_TEST(ColorSpace_Equals, r) { sk_sp<SkColorSpace> srgb = SkColorSpace::MakeSRGB(); auto parse = [&](const char* path) { sk_sp<SkData> data = GetResourceAsData(path); skcms_ICCProfile profile; REPORTER_ASSERT(r, skcms_Parse(data->data(), data->size(), &profile)); sk_sp<SkColorSpace> space = SkColorSpace::Make(profile); REPORTER_ASSERT(r, space); return space; }; sk_sp<SkColorSpace> z30 = parse("icc_profiles/HP_ZR30w.icc"); sk_sp<SkColorSpace> z32 = parse("icc_profiles/HP_Z32x.icc"); skcms_TransferFunction fn; fn.a = 1.0f; fn.b = 0.0f; fn.c = 1.0f; fn.d = 0.5f; fn.e = 0.0f; fn.f = 0.0f; fn.g = 1.0f; skcms_Matrix3x3 toXYZ = {{ { 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 }, }}; sk_sp<SkColorSpace> rgb4 = SkColorSpace::MakeRGB(fn, toXYZ); REPORTER_ASSERT(r, SkColorSpace::Equals(nullptr, nullptr)); REPORTER_ASSERT(r, SkColorSpace::Equals(srgb.get(), srgb.get())); REPORTER_ASSERT(r, SkColorSpace::Equals(z30.get(), z30.get())); REPORTER_ASSERT(r, SkColorSpace::Equals(z32.get(), z32.get())); REPORTER_ASSERT(r, SkColorSpace::Equals(rgb4.get(), rgb4.get())); REPORTER_ASSERT(r, !SkColorSpace::Equals(nullptr, srgb.get())); REPORTER_ASSERT(r, !SkColorSpace::Equals(srgb.get(), nullptr)); REPORTER_ASSERT(r, !SkColorSpace::Equals(z30.get(), srgb.get())); REPORTER_ASSERT(r, !SkColorSpace::Equals(z32.get(), z30.get())); REPORTER_ASSERT(r, !SkColorSpace::Equals(z30.get(), rgb4.get())); REPORTER_ASSERT(r, !SkColorSpace::Equals(srgb.get(), rgb4.get())); }
// 565 does not support alpha, but there is no reason for it not to support an // animated image with a frame that has alpha but then blends onto an opaque // frame making the result opaque. Test that we can decode such a frame. DEF_TEST(Codec_565, r) { sk_sp<SkData> data(GetResourceAsData("images/blendBG.webp")); if (!data) { return; } std::unique_ptr<SkCodec> codec(SkCodec::MakeFromData(std::move(data))); auto info = codec->getInfo().makeColorType(kRGB_565_SkColorType); SkBitmap bm; bm.allocPixels(info); SkCodec::Options options; options.fFrameIndex = 1; options.fPriorFrame = SkCodec::kNone; const auto result = codec->getPixels(info, bm.getPixels(), bm.rowBytes(), &options); REPORTER_ASSERT(r, result == SkCodec::kSuccess); }
// Verify that a webp image can be animated scaled down. This image has a // kRestoreBG frame, so it is an interesting image to test. After decoding that // frame, we have to erase its rectangle. The rectangle has to be adjusted // based on the scaled size. DEF_TEST(AndroidCodec_animated, r) { if (GetResourcePath().isEmpty()) { return; } const char* file = "images/required.webp"; sk_sp<SkData> data(GetResourceAsData(file)); if (!data) { ERRORF(r, "Missing %s", file); return; } auto codec = SkAndroidCodec::MakeFromCodec(SkCodec::MakeFromData(std::move(data))); if (!codec) { ERRORF(r, "Failed to decode %s", file); return; } auto info = codec->getInfo().makeAlphaType(kPremul_SkAlphaType); for (int sampleSize : { 8, 32, 100 }) { auto dimensions = codec->codec()->getScaledDimensions(1.0f / sampleSize); info = info.makeWH(dimensions.width(), dimensions.height()); SkBitmap bm; bm.allocPixels(info); SkCodec::Options options; for (int i = 0; i < codec->codec()->getFrameCount(); ++i) { SkCodec::FrameInfo frameInfo; REPORTER_ASSERT(r, codec->codec()->getFrameInfo(i, &frameInfo)); if (5 == i) { REPORTER_ASSERT(r, frameInfo.fDisposalMethod == SkCodecAnimation::DisposalMethod::kRestoreBGColor); } options.fFrameIndex = i; options.fPriorFrame = i - 1; info = info.makeAlphaType(frameInfo.fAlphaType); const auto result = codec->codec()->getPixels(info, bm.getPixels(), bm.rowBytes(), &options); REPORTER_ASSERT(r, result == SkCodec::kSuccess); } } }
// Test that some SkCodecs do not attempt to read input beyond the logical // end of the data. Some other SkCodecs do, but some Android apps rely on not // doing so for PNGs. Test on other formats that work. DEF_TEST(Codec_end, r) { for (const char* path : { "images/plane.png", "images/yellow_rose.png", "images/plane_interlaced.png", "images/google_chrome.ico", "images/color_wheel.ico", "images/mandrill.wbmp", "images/randPixels.bmp", }) { sk_sp<SkData> data = GetResourceAsData(path); if (!data) { continue; } const int kNumImages = 2; const size_t size = data->size(); sk_sp<SkData> multiData = SkData::MakeUninitialized(size * kNumImages); void* dst = multiData->writable_data(); for (int i = 0; i < kNumImages; i++) { memcpy(SkTAddOffset<void>(dst, size * i), data->data(), size); } data.reset(); SkMemoryStream stream(std::move(multiData)); for (int i = 0; i < kNumImages; ++i) { std::unique_ptr<SkCodec> codec(SkCodec::MakeFromStream( skstd::make_unique<UnowningStream>(&stream))); if (!codec) { ERRORF(r, "Failed to create a codec from %s, iteration %i", path, i); continue; } auto info = codec->getInfo().makeColorType(kN32_SkColorType); SkBitmap bm; bm.allocPixels(info); auto result = codec->getPixels(bm.info(), bm.getPixels(), bm.rowBytes()); if (result != SkCodec::kSuccess) { ERRORF(r, "Failed to getPixels from %s, iteration %i error %i", path, i, result); continue; } } } }
// This test uses file system operations that don't work out of the // box on iOS. It's likely that we don't need them on iOS. Ignoring for now. // TODO(stephana): Re-evaluate if we need this in the future. DEF_TEST(StreamPeek, reporter) { // Test a memory stream. const char gAbcs[] = "abcdefghijklmnopqrstuvwxyz"; SkMemoryStream memStream(gAbcs, strlen(gAbcs), false); test_fully_peekable_stream(reporter, &memStream, memStream.getLength()); // Test an arbitrary file stream. file streams do not support peeking. auto tmpdir = skiatest::GetTmpDir(); if (tmpdir.isEmpty()) { ERRORF(reporter, "no tmp dir!"); return; } auto path = SkOSPath::Join(tmpdir.c_str(), "file"); { SkFILEWStream wStream(path.c_str()); constexpr char filename[] = "images/baby_tux.webp"; auto data = GetResourceAsData(filename); if (!data || data->size() == 0) { ERRORF(reporter, "resource missing: %s\n", filename); return; } if (!wStream.isValid() || !wStream.write(data->data(), data->size())) { ERRORF(reporter, "error wrtiting to file %s", path.c_str()); return; } } SkFILEStream fileStream(path.c_str()); REPORTER_ASSERT(reporter, fileStream.isValid()); if (!fileStream.isValid()) { return; } SkAutoMalloc storage(fileStream.getLength()); for (size_t i = 1; i < fileStream.getLength(); i++) { REPORTER_ASSERT(reporter, fileStream.peek(storage.get(), i) == 0); } // Now test some FrontBufferedStreams for (size_t i = 1; i < memStream.getLength(); i++) { test_peeking_front_buffered_stream(reporter, memStream, i); } }
DEF_TEST(Codec_frames, r) { #define kOpaque kOpaque_SkAlphaType #define kUnpremul kUnpremul_SkAlphaType #define kKeep SkCodecAnimation::DisposalMethod::kKeep #define kRestoreBG SkCodecAnimation::DisposalMethod::kRestoreBGColor #define kRestorePrev SkCodecAnimation::DisposalMethod::kRestorePrevious static const struct { const char* fName; int fFrameCount; // One less than fFramecount, since the first frame is always // independent. std::vector<int> fRequiredFrames; // Same, since the first frame should match getInfo std::vector<SkAlphaType> fAlphas; // The size of this one should match fFrameCount for animated, empty // otherwise. std::vector<int> fDurations; int fRepetitionCount; std::vector<SkCodecAnimation::DisposalMethod> fDisposalMethods; } gRecs[] = { { "images/required.gif", 7, { 0, 1, 2, 3, 4, 5 }, { kOpaque, kUnpremul, kUnpremul, kUnpremul, kUnpremul, kUnpremul }, { 100, 100, 100, 100, 100, 100, 100 }, 0, { kKeep, kRestoreBG, kKeep, kKeep, kKeep, kRestoreBG, kKeep } }, { "images/alphabetAnim.gif", 13, { SkCodec::kNone, 0, 0, 0, 0, 5, 6, SkCodec::kNone, SkCodec::kNone, 9, 10, 11 }, { kUnpremul, kUnpremul, kUnpremul, kUnpremul, kUnpremul, kUnpremul, kUnpremul, kUnpremul, kUnpremul, kUnpremul, kUnpremul, kUnpremul }, { 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100 }, 0, { kKeep, kRestorePrev, kRestorePrev, kRestorePrev, kRestorePrev, kRestoreBG, kKeep, kRestoreBG, kRestoreBG, kKeep, kKeep, kRestoreBG, kKeep } }, { "images/randPixelsAnim2.gif", 4, // required frames { 0, 0, 1 }, // alphas { kOpaque, kOpaque, kOpaque }, // durations { 0, 1000, 170, 40 }, // repetition count 0, { kKeep, kKeep, kRestorePrev, kKeep } }, { "images/randPixelsAnim.gif", 13, // required frames { 0, 1, 2, 3, 4, 3, 6, 7, 7, 7, 9, 9 }, { kUnpremul, kUnpremul, kUnpremul, kUnpremul, kUnpremul, kUnpremul, kUnpremul, kUnpremul, kUnpremul, kUnpremul, kUnpremul, kUnpremul }, // durations { 0, 1000, 170, 40, 220, 7770, 90, 90, 90, 90, 90, 90, 90 }, // repetition count 0, { kKeep, kKeep, kKeep, kKeep, kRestoreBG, kRestoreBG, kRestoreBG, kRestoreBG, kRestorePrev, kRestoreBG, kRestorePrev, kRestorePrev, kRestorePrev, } }, { "images/box.gif", 1, {}, {}, {}, 0, { kKeep } }, { "images/color_wheel.gif", 1, {}, {}, {}, 0, { kKeep } }, { "images/test640x479.gif", 4, { 0, 1, 2 }, { kOpaque, kOpaque, kOpaque }, { 200, 200, 200, 200 }, SkCodec::kRepetitionCountInfinite, { kKeep, kKeep, kKeep, kKeep } }, { "images/colorTables.gif", 2, { 0 }, { kOpaque }, { 1000, 1000 }, 5, { kKeep, kKeep } }, { "images/arrow.png", 1, {}, {}, {}, 0, {} }, { "images/google_chrome.ico", 1, {}, {}, {}, 0, {} }, { "images/brickwork-texture.jpg", 1, {}, {}, {}, 0, {} }, #if defined(SK_CODEC_DECODES_RAW) && (!defined(_WIN32)) { "images/dng_with_preview.dng", 1, {}, {}, {}, 0, {} }, #endif { "images/mandrill.wbmp", 1, {}, {}, {}, 0, {} }, { "images/randPixels.bmp", 1, {}, {}, {}, 0, {} }, { "images/yellow_rose.webp", 1, {}, {}, {}, 0, {} }, { "images/webp-animated.webp", 3, { 0, 1 }, { kOpaque, kOpaque }, { 1000, 500, 1000 }, SkCodec::kRepetitionCountInfinite, { kKeep, kKeep, kKeep } }, { "images/blendBG.webp", 7, { 0, SkCodec::kNone, SkCodec::kNone, SkCodec::kNone, 4, 4 }, { kOpaque, kOpaque, kUnpremul, kOpaque, kUnpremul, kUnpremul }, { 525, 500, 525, 437, 609, 729, 444 }, 7, { kKeep, kKeep, kKeep, kKeep, kKeep, kKeep, kKeep } }, { "images/required.webp", 7, { 0, 1, 1, SkCodec::kNone, 4, 4 }, { kOpaque, kUnpremul, kUnpremul, kOpaque, kOpaque, kOpaque }, { 100, 100, 100, 100, 100, 100, 100 }, 1, { kKeep, kRestoreBG, kKeep, kKeep, kKeep, kRestoreBG, kKeep } }, }; #undef kOpaque #undef kUnpremul #undef kKeep #undef kRestorePrev #undef kRestoreBG for (const auto& rec : gRecs) { sk_sp<SkData> data(GetResourceAsData(rec.fName)); if (!data) { // Useful error statement, but sometimes people run tests without // resources, and they do not want to see these messages. //ERRORF(r, "Missing resources? Could not find '%s'", rec.fName); continue; } std::unique_ptr<SkCodec> codec(SkCodec::MakeFromData(data)); if (!codec) { ERRORF(r, "Failed to create an SkCodec from '%s'", rec.fName); continue; } { SkCodec::FrameInfo frameInfo; REPORTER_ASSERT(r, !codec->getFrameInfo(0, &frameInfo)); } const int repetitionCount = codec->getRepetitionCount(); if (repetitionCount != rec.fRepetitionCount) { ERRORF(r, "%s repetition count does not match! expected: %i\tactual: %i", rec.fName, rec.fRepetitionCount, repetitionCount); } const int expected = rec.fFrameCount; if (rec.fRequiredFrames.size() + 1 != static_cast<size_t>(expected)) { ERRORF(r, "'%s' has wrong number entries in fRequiredFrames; expected: %i\tactual: %i", rec.fName, expected - 1, rec.fRequiredFrames.size()); continue; } if (expected > 1) { if (rec.fDurations.size() != static_cast<size_t>(expected)) { ERRORF(r, "'%s' has wrong number entries in fDurations; expected: %i\tactual: %i", rec.fName, expected, rec.fDurations.size()); continue; } if (rec.fAlphas.size() + 1 != static_cast<size_t>(expected)) { ERRORF(r, "'%s' has wrong number entries in fAlphas; expected: %i\tactual: %i", rec.fName, expected - 1, rec.fAlphas.size()); continue; } if (rec.fDisposalMethods.size() != static_cast<size_t>(expected)) { ERRORF(r, "'%s' has wrong number entries in fDisposalMethods; " "expected %i\tactual: %i", rec.fName, expected, rec.fDisposalMethods.size()); continue; } } enum class TestMode { kVector, kIndividual, }; for (auto mode : { TestMode::kVector, TestMode::kIndividual }) { // Re-create the codec to reset state and test parsing. codec = SkCodec::MakeFromData(data); int frameCount; std::vector<SkCodec::FrameInfo> frameInfos; switch (mode) { case TestMode::kVector: frameInfos = codec->getFrameInfo(); // getFrameInfo returns empty set for non-animated. frameCount = frameInfos.empty() ? 1 : frameInfos.size(); break; case TestMode::kIndividual: frameCount = codec->getFrameCount(); break; } if (frameCount != expected) { ERRORF(r, "'%s' expected frame count: %i\tactual: %i", rec.fName, expected, frameCount); continue; } // From here on, we are only concerned with animated images. if (1 == frameCount) { continue; } for (int i = 0; i < frameCount; i++) { SkCodec::FrameInfo frameInfo; switch (mode) { case TestMode::kVector: frameInfo = frameInfos[i]; break; case TestMode::kIndividual: REPORTER_ASSERT(r, codec->getFrameInfo(i, nullptr)); REPORTER_ASSERT(r, codec->getFrameInfo(i, &frameInfo)); break; } if (rec.fDurations[i] != frameInfo.fDuration) { ERRORF(r, "%s frame %i's durations do not match! expected: %i\tactual: %i", rec.fName, i, rec.fDurations[i], frameInfo.fDuration); } auto to_string = [](SkAlphaType alpha) { switch (alpha) { case kUnpremul_SkAlphaType: return "unpremul"; case kOpaque_SkAlphaType: return "opaque"; default: SkASSERT(false); return "unknown"; } }; auto expectedAlpha = 0 == i ? codec->getInfo().alphaType() : rec.fAlphas[i-1]; auto alpha = frameInfo.fAlphaType; if (expectedAlpha != alpha) { ERRORF(r, "%s's frame %i has wrong alpha type! expected: %s\tactual: %s", rec.fName, i, to_string(expectedAlpha), to_string(alpha)); } if (0 == i) { REPORTER_ASSERT(r, frameInfo.fRequiredFrame == SkCodec::kNone); } else if (rec.fRequiredFrames[i-1] != frameInfo.fRequiredFrame) { ERRORF(r, "%s's frame %i has wrong dependency! expected: %i\tactual: %i", rec.fName, i, rec.fRequiredFrames[i-1], frameInfo.fRequiredFrame); } REPORTER_ASSERT(r, frameInfo.fDisposalMethod == rec.fDisposalMethods[i]); } if (TestMode::kIndividual == mode) { // No need to test decoding twice. continue; } // Compare decoding in multiple ways: // - Start from scratch for each frame. |codec| will have to decode the required frame // (and any it depends on) to decode. This is stored in |cachedFrames|. // - Provide the frame that a frame depends on, so |codec| just has to blend. // - Provide a frame after the required frame, which will be covered up by the newest // frame. // All should look the same. std::vector<SkBitmap> cachedFrames(frameCount); const auto info = codec->getInfo().makeColorType(kN32_SkColorType); auto decode = [&](SkBitmap* bm, int index, int cachedIndex) { auto decodeInfo = info; if (index > 0) { decodeInfo = info.makeAlphaType(frameInfos[index].fAlphaType); } bm->allocPixels(decodeInfo); if (cachedIndex != SkCodec::kNone) { // First copy the pixels from the cached frame const bool success = sk_tool_utils::copy_to(bm, kN32_SkColorType, cachedFrames[cachedIndex]); REPORTER_ASSERT(r, success); } SkCodec::Options opts; opts.fFrameIndex = index; opts.fPriorFrame = cachedIndex; const auto result = codec->getPixels(decodeInfo, bm->getPixels(), bm->rowBytes(), &opts); if (cachedIndex != SkCodec::kNone && restore_previous(frameInfos[cachedIndex])) { if (result == SkCodec::kInvalidParameters) { return true; } ERRORF(r, "Using a kRestorePrevious frame as fPriorFrame should fail"); return false; } if (result != SkCodec::kSuccess) { ERRORF(r, "Failed to decode frame %i from %s when providing prior frame %i, " "error %i", index, rec.fName, cachedIndex, result); } return result == SkCodec::kSuccess; }; for (int i = 0; i < frameCount; i++) { SkBitmap& cachedFrame = cachedFrames[i]; if (!decode(&cachedFrame, i, SkCodec::kNone)) { continue; } const auto reqFrame = frameInfos[i].fRequiredFrame; if (reqFrame == SkCodec::kNone) { // Nothing to compare against. continue; } for (int j = reqFrame; j < i; j++) { SkBitmap frame; if (restore_previous(frameInfos[j])) { (void) decode(&frame, i, j); continue; } if (!decode(&frame, i, j)) { continue; } // Now verify they're equal. const size_t rowLen = info.bytesPerPixel() * info.width(); for (int y = 0; y < info.height(); y++) { const void* cachedAddr = cachedFrame.getAddr(0, y); SkASSERT(cachedAddr != nullptr); const void* addr = frame.getAddr(0, y); SkASSERT(addr != nullptr); const bool lineMatches = memcmp(cachedAddr, addr, rowLen) == 0; if (!lineMatches) { SkString name = SkStringPrintf("cached_%i", i); write_bm(name.c_str(), cachedFrame); name = SkStringPrintf("frame_%i", i); write_bm(name.c_str(), frame); ERRORF(r, "%s's frame %i is different (starting from line %i) when " "providing prior frame %i!", rec.fName, i, y, j); break; } } } } } } }
static sk_sp<SkImage> make_codec_image() { sk_sp<SkData> encoded = GetResourceAsData("images/randPixels.png"); return SkImage::MakeFromEncoded(encoded); }