AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Respect repetition count in SkAnimatedImage

Browse Source 
Bug: b/63908092

By default use the repetition count stored in the encoded data (if
any). Allow setting the repetition count manually, so that the
animation will stop after n+1 total cycles (unless -1 is used for
infinite).

If the animation is complete, make start reset it.

When the animation is not running, make update return max double (i.e.
no need to update any time soon).

Fix a bug where the first call to update returned -1.

Share write_bm with CodecAnimTest, for debugging.

Update Sample to check isRunning rather than keeping its own record
of whether the animation is running.

Change-Id: I883e4d7325f7a7b23a422fa9d756f9ea3018f0f8
Reviewed-on: https://skia-review.googlesource.com/97082
Reviewed-by: Derek Sollenberger <djsollen@google.com>
Commit-Queue: Leon Scroggins <scroggo@google.com>
This commit is contained in:
Leon Scroggins III 2018-01-20 10:33:24 -05:00 committed by Skia Commit-Bot
parent 19dd8fbabf
commit 4c11945a97
7 changed files with 335 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
gn/tests.gni
View File

@ -8,6 +8,7 @@ _tests = get_path_info("../tests", "abspath")
tests_sources = [
"$_tests/AndroidCodecTest.cpp",
"$_tests/AnimatedImageTest.cpp",
"$_tests/AAClipTest.cpp",
"$_tests/AnnotationTest.cpp",
"$_tests/ApplyGammaTest.cpp",

18
include/android/SkAnimatedImage.h
View File

@ -76,6 +76,17 @@ public:
*/
double update(double msecs);
/**
* Change the repetition count.
*
* By default, the image will repeat the number of times indicated in the
* encoded data.
*
* Use SkCodec::kRepetitionCountInfinite for infinite, and 0 to show all
* frames once and then stop.
*/
void setRepetitionCount(int count);
protected:
SkRect onGetBounds() override;
void onDraw(SkCanvas*) override;
@ -95,6 +106,7 @@ private:
const SkImageInfo fDecodeInfo;
const SkIRect fCropRect;
const sk_sp<SkPicture> fPostProcess;
const int fFrameCount;
const bool fSimple; // no crop, scale, or postprocess
SkMatrix fMatrix; // used only if !fSimple
@ -104,9 +116,15 @@ private:
double fRemainingMS;
Frame fActiveFrame;
Frame fRestoreFrame;
int fRepetitionCount;
int fRepetitionsCompleted;
SkAnimatedImage(std::unique_ptr<SkAndroidCodec>, SkISize scaledSize,
SkImageInfo decodeInfo, SkIRect cropRect, sk_sp<SkPicture> postProcess);
SkAnimatedImage(std::unique_ptr<SkAndroidCodec>);
int computeNextFrame(int current, bool* animationEnded);
double finish();
typedef SkDrawable INHERITED;
};

6
samplecode/SampleAnimatedImage.cpp
View File

@ -25,7 +25,6 @@ class SampleAnimatedImage : public SampleView {
public:
SampleAnimatedImage()
: INHERITED()
, fRunning(false)
, fYOffset(0)
{}
@ -95,12 +94,10 @@ protected:
if (fImage && SampleCode::CharQ(*evt, &uni)) {
switch (uni) {
case kPauseKey:
if (fRunning) {
if (fImage->isRunning()) {
fImage->stop();
fRunning = false;
} else {
fImage->start();
fRunning = true;
}
return true;
case kResetKey:
@ -116,7 +113,6 @@ protected:
private:
sk_sp<SkAnimatedImage> fImage;
sk_sp<SkDrawable> fDrawable;
bool fRunning;
SkScalar fYOffset;
typedef SampleView INHERITED;
};

85
src/android/SkAnimatedImage.cpp
View File

@ -68,12 +68,15 @@ SkAnimatedImage::SkAnimatedImage(std::unique_ptr<SkAndroidCodec> codec, SkISize
, fDecodeInfo(decodeInfo)
, fCropRect(cropRect)
, fPostProcess(std::move(postProcess))
, fFrameCount(fCodec->codec()->getFrameCount())
, fSimple(fScaledSize == fDecodeInfo.dimensions() && !fPostProcess
&& fCropRect == fDecodeInfo.bounds())
, fFinished(false)
, fRunning(false)
, fNowMS(kInit)
, fRemainingMS(kInit)
, fRepetitionCount(fCodec->codec()->getRepetitionCount())
, fRepetitionsCompleted(0)
{
if (!fActiveFrame.fBitmap.tryAllocPixels(fDecodeInfo)) {
return;
@ -113,6 +116,9 @@ bool SkAnimatedImage::Frame::copyTo(Frame* dst) const {
void SkAnimatedImage::start() {
fRunning = true;
if (fFinished) {
this->reset();
}
}
void SkAnimatedImage::stop() {
@ -120,6 +126,8 @@ void SkAnimatedImage::stop() {
}
void SkAnimatedImage::reset() {
fFinished = false;
fRepetitionsCompleted = 0;
this->update(kInit);
}
@ -127,6 +135,30 @@ static bool is_restore_previous(SkCodecAnimation::DisposalMethod dispose) {
return SkCodecAnimation::DisposalMethod::kRestorePrevious == dispose;
}
int SkAnimatedImage::computeNextFrame(int current, bool* animationEnded) {
SkASSERT(animationEnded != nullptr);
*animationEnded = false;
const int frameToDecode = current + 1;
if (frameToDecode == fFrameCount - 1) {
// Final frame. Check to determine whether to stop.
fRepetitionsCompleted++;
if (fRepetitionCount != SkCodec::kRepetitionCountInfinite
&& fRepetitionsCompleted > fRepetitionCount) {
*animationEnded = true;
}
} else if (frameToDecode == fFrameCount) {
return 0;
}
return frameToDecode;
}
double SkAnimatedImage::finish() {
fFinished = true;
fRunning = false;
return std::numeric_limits<double>::max();
}
double SkAnimatedImage::update(double msecs) {
if (fFinished) {
return std::numeric_limits<double>::max();
@ -136,19 +168,25 @@ double SkAnimatedImage::update(double msecs) {
fNowMS = msecs;
const double msSinceLastUpdate = fNowMS - lastUpdateMS;
const int frameCount = fCodec->codec()->getFrameCount();
bool animationEnded = false;
int frameToDecode = SkCodec::kNone;
if (kInit == msecs) {
frameToDecode = 0;
fNowMS = lastUpdateMS;
} else {
if (!fRunning || lastUpdateMS == kInit) {
return kInit;
if (!fRunning) {
return std::numeric_limits<double>::max();
}
if (lastUpdateMS == kInit) {
return fRemainingMS + fNowMS;
}
if (msSinceLastUpdate < fRemainingMS) {
fRemainingMS -= msSinceLastUpdate;
return fRemainingMS + fNowMS;
} else {
frameToDecode = (fActiveFrame.fIndex + 1) % frameCount;
frameToDecode = this->computeNextFrame(fActiveFrame.fIndex, &animationEnded);
}
}
@ -156,8 +194,7 @@ double SkAnimatedImage::update(double msecs) {
if (fCodec->codec()->getFrameInfo(frameToDecode, &frameInfo)) {
if (!frameInfo.fFullyReceived) {
SkCodecPrintf("Frame %i not fully received\n", frameToDecode);
fFinished = true;
return std::numeric_limits<double>::max();
return this->finish();
}
if (kInit == msecs) {
@ -168,22 +205,22 @@ double SkAnimatedImage::update(double msecs) {
while (pastUpdate >= frameInfo.fDuration) {
SkCodecPrintf("Skipping frame %i\n", frameToDecode);
pastUpdate -= frameInfo.fDuration;
frameToDecode = (frameToDecode + 1) % frameCount;
frameToDecode = computeNextFrame(frameToDecode, &animationEnded);
if (!fCodec->codec()->getFrameInfo(frameToDecode, &frameInfo)) {
SkCodecPrintf("Could not getFrameInfo for frame %i",
frameToDecode);
// Prior call to getFrameInfo succeeded, so use that one.
frameToDecode--;
fFinished = true;
animationEnded = true;
if (frameToDecode < 0) {
return std::numeric_limits<double>::max();
return this->finish();
}
}
}
fRemainingMS = frameInfo.fDuration - pastUpdate;
}
} else {
fFinished = true;
animationEnded = true;
if (0 == frameToDecode) {
// Static image. This is okay.
frameInfo.fRequiredFrame = SkCodec::kNone;
@ -194,16 +231,22 @@ double SkAnimatedImage::update(double msecs) {
} else {
SkCodecPrintf("Error getting frameInfo for frame %i\n",
frameToDecode);
return std::numeric_limits<double>::max();
return this->finish();
}
}
if (frameToDecode == fActiveFrame.fIndex) {
if (animationEnded) {
return this->finish();
}
return fRemainingMS + fNowMS;
}
if (frameToDecode == fRestoreFrame.fIndex) {
SkTSwap(fActiveFrame, fRestoreFrame);
if (animationEnded) {
return this->finish();
}
return fRemainingMS + fNowMS;
}
@ -245,8 +288,7 @@ double SkAnimatedImage::update(double msecs) {
SkTSwap(fActiveFrame, fRestoreFrame);
} else if (!fRestoreFrame.copyTo(&fActiveFrame)) {
SkCodecPrintf("Failed to restore frame\n");
fFinished = true;
return std::numeric_limits<double>::max();
return this->finish();
}
options.fPriorFrame = fActiveFrame.fIndex;
}
@ -260,22 +302,23 @@ double SkAnimatedImage::update(double msecs) {
} else {
auto info = fDecodeInfo.makeAlphaType(alphaType);
if (!dst->tryAllocPixels(info)) {
fFinished = true;
return std::numeric_limits<double>::max();
return this->finish();
}
}
auto result = fCodec->codec()->getPixels(dst->info(), dst->getPixels(), dst->rowBytes(),
&options);
if (result != SkCodec::kSuccess) {
SkCodecPrintf("error %i, frame %i of %i\n", result, frameToDecode, frameCount);
// Reset to the beginning.
fActiveFrame.fIndex = SkCodec::kNone;
return 0.0;
SkCodecPrintf("error %i, frame %i of %i\n", result, frameToDecode, fFrameCount);
return this->finish();
}
fActiveFrame.fIndex = frameToDecode;
fActiveFrame.fDisposalMethod = frameInfo.fDisposalMethod;
if (animationEnded) {
return this->finish();
}
return fRemainingMS + fNowMS;
}
@ -302,3 +345,7 @@ void SkAnimatedImage::onDraw(SkCanvas* canvas) {
canvas->restore();
}
}
void SkAnimatedImage::setRepetitionCount(int newCount) {
fRepetitionCount = newCount;
}

229
tests/AnimatedImageTest.cpp Normal file
View File

@ -0,0 +1,229 @@
/*
* 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;
}
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 == std::numeric_limits<double>::max());
REPORTER_ASSERT(r, !animatedImage->isRunning());
} else {
REPORTER_ASSERT(r, animatedImage->isRunning());
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());
currentTime = next;
double stoppedNext = animatedImage->update(currentTime);
REPORTER_ASSERT(r, stoppedNext == std::numeric_limits<double>::max());
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());
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);
for (int loops = 0; loops <= loopCount; loops++) {
REPORTER_ASSERT(r, animatedImage->isRunning());
for (size_t i = 0; i < frameInfos.size(); ++i) {
double next = animatedImage->update(currentTime);
if (animatedImage->isRunning()) {
currentTime = next;
}
}
}
if (animatedImage->isRunning()) {
ERRORF(r, "%s animation still running after %i loops", file, loopCount);
}
}
}
}

17
tests/CodecAnimTest.cpp
View File

@ -8,11 +8,9 @@
#include "SkAndroidCodec.h"
#include "SkBitmap.h"
#include "SkCodec.h"
#include "SkCommonFlags.h"
#include "SkImageEncoder.h"
#include "SkOSPath.h"
#include "SkStream.h"
#include "CodecPriv.h"
#include "Resources.h"
#include "Test.h"
#include "sk_tool_utils.h"
@ -20,19 +18,6 @@
#include <initializer_list>
#include <vector>
static void write_bm(const char* name, const SkBitmap& bm) {
if (FLAGS_writePath.isEmpty()) {
return;
}
SkString filename = SkOSPath::Join(FLAGS_writePath[0], name);
filename.appendf(".png");
SkFILEWStream file(filename.c_str());
if (!SkEncodeImage(&file, bm, SkEncodedImageFormat::kPNG, 100)) {
SkDebugf("failed to write '%s'\n", filename.c_str());
}
}
DEF_TEST(Codec_trunc, r) {
sk_sp<SkData> data(GetResourceAsData("images/box.gif"));
if (!data) {

19
tests/CodecPriv.h
View File

@ -9,7 +9,12 @@
#include "SkBitmap.h"
#include "SkCodec.h"
#include "SkCommonFlags.h"
#include "SkData.h"
#include "SkEncodedImageFormat.h"
#include "SkImageEncoder.h"
#include "SkOSPath.h"
#include "SkStream.h"
inline bool decode_memory(const void* mem, size_t size, SkBitmap* bm) {
std::unique_ptr<SkCodec> codec(SkCodec::MakeFromData(SkData::MakeWithoutCopy(mem, size)));
@ -22,4 +27,18 @@ inline bool decode_memory(const void* mem, size_t size, SkBitmap* bm) {
bm->rowBytes());
return result == SkCodec::kSuccess || result == SkCodec::kIncompleteInput;
}
inline void write_bm(const char* name, const SkBitmap& bm) {
if (FLAGS_writePath.isEmpty()) {
return;
}
SkString filename = SkOSPath::Join(FLAGS_writePath[0], name);
filename.appendf(".png");
SkFILEWStream file(filename.c_str());
if (!SkEncodeImage(&file, bm, SkEncodedImageFormat::kPNG, 100)) {
SkDebugf("failed to write '%s'\n", filename.c_str());
}
}
#endif // CodecPriv_DEFINED