| /* |
| * Copyright 2018 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "SkAndroidCodec.h" |
| #include "SkAnimatedImage.h" |
| #include "SkCanvas.h" |
| #include "SkCodec.h" |
| #include "SkUnPreMultiply.h" |
| |
| #include "CodecPriv.h" |
| #include "Resources.h" |
| #include "Test.h" |
| #include "sk_tool_utils.h" |
| |
| #include <vector> |
| |
| DEF_TEST(AnimatedImage, r) { |
| if (GetResourcePath().isEmpty()) { |
| return; |
| } |
| for (const char* file : { "images/alphabetAnim.gif", |
| "images/colorTables.gif", |
| "images/webp-animated.webp", |
| "images/required.webp", |
| }) { |
| auto data = GetResourceAsData(file); |
| if (!data) { |
| ERRORF(r, "Could not get %s", file); |
| continue; |
| } |
| |
| auto codec = SkCodec::MakeFromData(data); |
| if (!codec) { |
| ERRORF(r, "Could not create codec for %s", file); |
| continue; |
| } |
| |
| const int defaultRepetitionCount = codec->getRepetitionCount(); |
| std::vector<SkCodec::FrameInfo> frameInfos = codec->getFrameInfo(); |
| std::vector<SkBitmap> frames(frameInfos.size()); |
| // Used down below for our test image. |
| const auto imageInfo = codec->getInfo().makeAlphaType(kPremul_SkAlphaType); |
| |
| for (size_t i = 0; i < frameInfos.size(); ++i) { |
| auto info = codec->getInfo().makeAlphaType(frameInfos[i].fAlphaType); |
| auto& bm = frames[i]; |
| |
| SkCodec::Options options; |
| options.fFrameIndex = (int) i; |
| options.fPriorFrame = frameInfos[i].fRequiredFrame; |
| if (options.fPriorFrame == SkCodec::kNone) { |
| bm.allocPixels(info); |
| bm.eraseColor(0); |
| } else { |
| const SkBitmap& priorFrame = frames[options.fPriorFrame]; |
| if (!sk_tool_utils::copy_to(&bm, priorFrame.colorType(), priorFrame)) { |
| ERRORF(r, "Failed to copy %s frame %i", file, options.fPriorFrame); |
| options.fPriorFrame = SkCodec::kNone; |
| } |
| REPORTER_ASSERT(r, bm.setAlphaType(frameInfos[i].fAlphaType)); |
| } |
| |
| auto result = codec->getPixels(info, bm.getPixels(), bm.rowBytes(), &options); |
| if (result != SkCodec::kSuccess) { |
| ERRORF(r, "error in %s frame %zu: %s", file, i, SkCodec::ResultToString(result)); |
| } |
| } |
| |
| auto androidCodec = SkAndroidCodec::MakeFromCodec(std::move(codec)); |
| if (!androidCodec) { |
| ERRORF(r, "Could not create androidCodec for %s", file); |
| continue; |
| } |
| |
| auto animatedImage = SkAnimatedImage::Make(std::move(androidCodec)); |
| if (!animatedImage) { |
| ERRORF(r, "Could not create animated image for %s", file); |
| continue; |
| } |
| |
| REPORTER_ASSERT(r, defaultRepetitionCount == animatedImage->getRepetitionCount()); |
| |
| auto testDraw = [r, &frames, &imageInfo, file](const sk_sp<SkAnimatedImage>& animatedImage, |
| int expectedFrame) { |
| SkBitmap test; |
| test.allocPixels(imageInfo); |
| test.eraseColor(0); |
| SkCanvas c(test); |
| animatedImage->draw(&c); |
| |
| const SkBitmap& frame = frames[expectedFrame]; |
| REPORTER_ASSERT(r, frame.colorType() == test.colorType()); |
| REPORTER_ASSERT(r, frame.dimensions() == test.dimensions()); |
| for (int i = 0; i < test.width(); ++i) |
| for (int j = 0; j < test.height(); ++j) { |
| SkColor expected = SkUnPreMultiply::PMColorToColor(*frame.getAddr32(i, j)); |
| SkColor actual = SkUnPreMultiply::PMColorToColor(*test .getAddr32(i, j)); |
| if (expected != actual) { |
| ERRORF(r, "frame %i of %s does not match at pixel %i, %i!" |
| " expected %x\tactual: %x", |
| expectedFrame, file, i, j, expected, actual); |
| SkString expected_name = SkStringPrintf("expected_%c", '0' + expectedFrame); |
| SkString actual_name = SkStringPrintf("actual_%c", '0' + expectedFrame); |
| write_bm(expected_name.c_str(), frame); |
| write_bm(actual_name.c_str(), test); |
| return false; |
| } |
| } |
| return true; |
| }; |
| |
| REPORTER_ASSERT(r, !animatedImage->isRunning()); |
| if (!testDraw(animatedImage, 0)) { |
| ERRORF(r, "Did not start with frame 0"); |
| continue; |
| } |
| |
| animatedImage->start(); |
| REPORTER_ASSERT(r, animatedImage->isRunning()); |
| if (!testDraw(animatedImage, 0)) { |
| ERRORF(r, "After starting, still not on frame 0"); |
| continue; |
| } |
| |
| // Start at an arbitrary time. |
| double currentTime = 100000; |
| bool failed = false; |
| for (size_t i = 0; i < frameInfos.size(); ++i) { |
| double next = animatedImage->update(currentTime); |
| if (i == frameInfos.size() - 1 && defaultRepetitionCount == 0) { |
| REPORTER_ASSERT(r, next == SkAnimatedImage::kNotRunning); |
| REPORTER_ASSERT(r, !animatedImage->isRunning()); |
| REPORTER_ASSERT(r, animatedImage->isFinished()); |
| } else { |
| REPORTER_ASSERT(r, animatedImage->isRunning()); |
| REPORTER_ASSERT(r, !animatedImage->isFinished()); |
| double expectedNext = currentTime + frameInfos[i].fDuration; |
| if (next != expectedNext) { |
| ERRORF(r, "Time did not match for frame %i: next: %g expected: %g", |
| i, next, expectedNext); |
| failed = true; |
| break; |
| } |
| } |
| |
| if (!testDraw(animatedImage, i)) { |
| ERRORF(r, "Did not update to %i properly", i); |
| failed = true; |
| break; |
| } |
| |
| // Update, but not to the next frame. |
| REPORTER_ASSERT(r, animatedImage->update((next - currentTime) / 2) == next); |
| if (!testDraw(animatedImage, i)) { |
| ERRORF(r, "Should still be on frame %i", i); |
| failed = true; |
| break; |
| } |
| |
| currentTime = next; |
| } |
| |
| if (failed) { |
| continue; |
| } |
| |
| // Create a new animated image and test stop. |
| animatedImage = SkAnimatedImage::Make(SkAndroidCodec::MakeFromCodec( |
| SkCodec::MakeFromData(data))); |
| |
| animatedImage->start(); |
| currentTime = 100000; |
| // Do not go to the last frame, so it should still be running after. |
| for (size_t i = 0; i < frameInfos.size() - 1; ++i) { |
| double next = animatedImage->update(currentTime); |
| if (!testDraw(animatedImage, i)) { |
| ERRORF(r, "Error during stop tests."); |
| failed = true; |
| break; |
| } |
| |
| double interval = next - currentTime; |
| animatedImage->stop(); |
| REPORTER_ASSERT(r, !animatedImage->isRunning()); |
| REPORTER_ASSERT(r, !animatedImage->isFinished()); |
| |
| currentTime = next; |
| double stoppedNext = animatedImage->update(currentTime); |
| REPORTER_ASSERT(r, stoppedNext == SkAnimatedImage::kNotRunning); |
| if (!testDraw(animatedImage, i)) { |
| ERRORF(r, "Advanced the frame while stopped?"); |
| failed = true; |
| break; |
| } |
| |
| animatedImage->start(); |
| currentTime += interval; |
| } |
| |
| if (failed) { |
| return; |
| } |
| |
| REPORTER_ASSERT(r, animatedImage->isRunning()); |
| REPORTER_ASSERT(r, !animatedImage->isFinished()); |
| animatedImage->reset(); |
| if (!testDraw(animatedImage, 0)) { |
| ERRORF(r, "reset failed"); |
| continue; |
| } |
| |
| for (int loopCount : { 0, 1, 2, 5 }) { |
| animatedImage = SkAnimatedImage::Make(SkAndroidCodec::MakeFromCodec( |
| SkCodec::MakeFromData(data))); |
| animatedImage->start(); |
| animatedImage->setRepetitionCount(loopCount); |
| REPORTER_ASSERT(r, animatedImage->getRepetitionCount() == loopCount); |
| |
| for (int loops = 0; loops <= loopCount; loops++) { |
| REPORTER_ASSERT(r, animatedImage->isRunning()); |
| REPORTER_ASSERT(r, !animatedImage->isFinished()); |
| for (size_t i = 0; i < frameInfos.size(); ++i) { |
| double next = animatedImage->update(currentTime); |
| if (animatedImage->isRunning()) { |
| currentTime = next; |
| } else { |
| REPORTER_ASSERT(r, next == SkAnimatedImage::kNotRunning); |
| } |
| } |
| } |
| |
| if (animatedImage->isRunning()) { |
| ERRORF(r, "%s animation still running after %i loops", file, loopCount); |
| } |
| |
| if (!animatedImage->isFinished()) { |
| ERRORF(r, "%s animation should have finished with specified loop count (%i)", |
| file, loopCount); |
| } |
| } |
| } |
| } |