AnimatedImageTest.cpp

Go to the documentation of this file.

/*
 * 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 "include/android/SkAnimatedImage.h"
#include "include/codec/SkAndroidCodec.h"
#include "include/codec/SkCodec.h"
#include "include/core/SkAlphaType.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkData.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkPicture.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkTypes.h"
#include "include/core/SkUnPreMultiply.h"
#include "tests/CodecPriv.h"
#include "tests/Test.h"
#include "tools/Resources.h"
#include "tools/ToolUtils.h"
 
#include <cstddef>
#include <initializer_list>
#include <memory>
#include <utility>
#include <vector>
 
DEF_TEST(AnimatedImage_simple, r) {
    if (GetResourcePath().isEmpty()) {
        return;
    }
 
    const char* file = "images/stoplight_h.webp";
    auto data = GetResourceAsData(file);
    if (!data) {
        ERRORF(r, "Could not get %s", file);
        return;
    }
 
    // An animated image with a non-default exif orientation is no longer
    // "simple"; verify that the assert has been removed.
    auto androidCodec = SkAndroidCodec::MakeFromData(std::move(data));
    auto animatedImage = SkAnimatedImage::Make(std::move(androidCodec));
    REPORTER_ASSERT(r, animatedImage);
}
 
DEF_TEST(AnimatedImage_rotation, r) {
    if (GetResourcePath().isEmpty()) {
        return;
    }
 
    // These images use different exif orientations to achieve the same final
    // dimensions
    const auto expectedBounds = SkRect::MakeIWH(100, 80);
    for (int i = 1; i <=8; i++) {
        for (const SkString& name : { SkStringPrintf("images/orientation/%d.webp", i),
                                      SkStringPrintf("images/orientation/%d_444.jpg", i) }) {
 
            const char* file = name.c_str();
            auto data = GetResourceAsData(file);
            if (!data) {
                ERRORF(r, "Could not get %s", file);
                return;
            }
 
            auto androidCodec = SkAndroidCodec::MakeFromData(std::move(data));
            auto animatedImage = SkAnimatedImage::Make(std::move(androidCodec));
            if (!animatedImage) {
                ERRORF(r, "Failed to create animated image from %s", file);
                return;
            }
 
            auto bounds = animatedImage->getBounds();
            if (bounds != expectedBounds) {
                ERRORF(r, "Mismatched bounds for %s", file);
                bounds.dump();
            }
        }
    }
}
 
DEF_TEST(AnimatedImage_invalidCrop, r) {
    if (GetResourcePath().isEmpty()) {
        return;
    }
 
    const char* file = "images/alphabetAnim.gif";
    auto data = GetResourceAsData(file);
    if (!data) {
        ERRORF(r, "Could not get %s", file);
        return;
    }
 
    const struct Rec {
        bool    valid;
        SkISize scaledSize;
        SkIRect cropRect;
    } gRecs[] = {
        // cropRect contained by original dimensions
        { true,  {100, 100}, {   0,  0, 100, 100} },
        { true,  {100, 100}, {   0,  0,  50,  50} },
        { true,  {100, 100}, {  10, 10, 100, 100} },
        { true,  {100, 100}, {   0,  0, 100, 100} },
 
        // unsorted cropRect
        { false, {100, 100}, {   0, 100, 100,   0} },
        { false, {100, 100}, { 100,   0,   0, 100} },
 
        // cropRect not contained by original dimensions
        { false, {100, 100}, {   0,   1, 100, 101} },
        { false, {100, 100}, {   0,  -1, 100,  99} },
        { false, {100, 100}, {  -1,   0,  99, 100} },
        { false, {100, 100}, { 100, 100, 200, 200} },
 
        // cropRect contained by scaled dimensions
        { true,  { 50,  50}, {   0,   0,  50,  50} },
        { true,  { 50,  50}, {   0,   0,  25,  25} },
        { true,  {200, 200}, {   0,   1, 100, 101} },
 
        // cropRect not contained by scaled dimensions
        { false, { 50,  50}, {   0,   0,  75,  25} },
        { false, { 50,  50}, {   0,   0,  25,  75} },
 
    };
    for (const auto& rec : gRecs) {
        auto codec = SkAndroidCodec::MakeFromData(data);
        if (!codec) {
            ERRORF(r, "Could not create codec for %s", file);
            return;
        }
 
        auto info = codec->getInfo();
        REPORTER_ASSERT(r, info.dimensions() == SkISize::Make(100, 100));
 
        auto image = SkAnimatedImage::Make(std::move(codec), info.makeDimensions(rec.scaledSize),
                rec.cropRect, nullptr);
 
        REPORTER_ASSERT(r, rec.valid == !!image.get());
    }
}
 
DEF_TEST(AnimatedImage_scaled, r) {
    if (GetResourcePath().isEmpty()) {
        return;
    }
 
    const char* file = "images/alphabetAnim.gif";
    auto data = GetResourceAsData(file);
    if (!data) {
        ERRORF(r, "Could not get %s", file);
        return;
    }
 
    auto codec = SkAndroidCodec::MakeFromCodec(SkCodec::MakeFromData(data));
    if (!codec) {
        ERRORF(r, "Could not create codec for %s", file);
        return;
    }
 
    // Force the drawable follow its special case that requires scaling.
    auto info = codec->getInfo();
    info = info.makeWH(info.width() - 5, info.height() - 5);
    auto rect = info.bounds();
    auto image = SkAnimatedImage::Make(std::move(codec), info, rect, nullptr);
    if (!image) {
        ERRORF(r, "Failed to create animated image for %s", file);
        return;
    }
 
    // Clear a bitmap to non-transparent and draw to it. pixels that are transparent
    // in the image should not replace the original non-transparent color.
    SkBitmap bm;
    bm.allocPixels(SkImageInfo::MakeN32Premul(info.width(), info.height()));
    bm.eraseColor(SK_ColorBLUE);
    SkCanvas canvas(bm);
    image->draw(&canvas);
    for (int i = 0; i < info.width();  ++i)
    for (int j = 0; j < info.height(); ++j) {
        if (*bm.getAddr32(i, j) == SK_ColorTRANSPARENT) {
            ERRORF(r, "Erased color underneath!");
            return;
        }
    }
}
 
static bool compare_bitmaps(skiatest::Reporter* r,
                            const char* file,
                            int expectedFrame,
                            const SkBitmap& expectedBm,
                            const SkBitmap& actualBm) {
    REPORTER_ASSERT(r, expectedBm.colorType() == actualBm.colorType());
    REPORTER_ASSERT(r, expectedBm.dimensions() == actualBm.dimensions());
    for (int i = 0; i < actualBm.width();  ++i)
    for (int j = 0; j < actualBm.height(); ++j) {
        SkColor expected = SkUnPreMultiply::PMColorToColor(*expectedBm.getAddr32(i, j));
        SkColor actual   = SkUnPreMultiply::PMColorToColor(*actualBm  .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(), expectedBm);
            write_bm(actual_name.c_str(),   actualBm);
            return false;
        }
    }
    return true;
}
 
DEF_TEST(AnimatedImage_copyOnWrite, r) {
    if (GetResourcePath().isEmpty()) {
        return;
    }
    for (const char* file : { "images/alphabetAnim.gif",
                              "images/colorTables.gif",
                              "images/stoplight.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 auto imageInfo = codec->getInfo().makeAlphaType(kPremul_SkAlphaType);
        const int frameCount = codec->getFrameCount();
        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;
        }
        animatedImage->setRepetitionCount(0);
 
        std::vector<SkBitmap> expected(frameCount);
        std::vector<sk_sp<SkPicture>> pictures(frameCount);
        for (int i = 0; i < frameCount; i++) {
            SkBitmap& bm = expected[i];
            bm.allocPixels(imageInfo);
            bm.eraseColor(SK_ColorTRANSPARENT);
            SkCanvas canvas(bm);
 
            pictures[i] = animatedImage->makePictureSnapshot();
            canvas.drawPicture(pictures[i]);
 
            const auto duration = animatedImage->decodeNextFrame();
            // We're attempting to decode i + 1, so decodeNextFrame will return
            // kFinished if that is the last frame (or we attempt to decode one
            // more).
            if (i >= frameCount - 2) {
                REPORTER_ASSERT(r, duration == SkAnimatedImage::kFinished);
            } else {
                REPORTER_ASSERT(r, duration != SkAnimatedImage::kFinished);
            }
        }
 
        for (int i = 0; i < frameCount; i++) {
            SkBitmap test;
            test.allocPixels(imageInfo);
            test.eraseColor(SK_ColorTRANSPARENT);
            SkCanvas canvas(test);
 
            canvas.drawPicture(pictures[i]);
 
            compare_bitmaps(r, file, i, expected[i], test);
        }
    }
}
 
DEF_TEST(AnimatedImage, r) {
    if (GetResourcePath().isEmpty()) {
        return;
    }
    for (const char* file : { "images/alphabetAnim.gif",
                              "images/colorTables.gif",
                              "images/stoplight.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;
        }
 
        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);
 
        // Get the repetition count after the codec->getFrameInfo() call above
        // has walked to the end of the encoded image.
        //
        // At the file format level, GIF images can declare their repetition
        // count multiple times and our codec goes with "last one wins".
        // Furthermore, for single-frame (still) GIF images, a zero, positive
        // or infinite repetition count are all equivalent in practice (in all
        // cases, the pixels do not change over time), so the codec has some
        // leeway in what to return for single-frame GIF images, but it cannot
        // distinguish single-frame from multiple-frame GIFs until we count the
        // number of frames (e.g. call getFrameInfo).
        const int defaultRepetitionCount = codec->getRepetitionCount();
 
        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::kNoFrame) {
                bm.allocPixels(info);
                bm.eraseColor(0);
            } else {
                const SkBitmap& priorFrame = frames[options.fPriorFrame];
                if (!ToolUtils::copy_to(&bm, priorFrame.colorType(), priorFrame)) {
                    ERRORF(r, "Failed to copy %s frame %i", file, options.fPriorFrame);
                    options.fPriorFrame = SkCodec::kNoFrame;
                }
                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];
            return compare_bitmaps(r, file, expectedFrame, frame, test);
        };
 
        REPORTER_ASSERT(r, animatedImage->currentFrameDuration() == frameInfos[0].fDuration);
 
        if (!testDraw(animatedImage, 0)) {
            ERRORF(r, "Did not start with frame 0");
            continue;
        }
 
        // Start at an arbitrary time.
        bool failed = false;
        for (size_t i = 1; i < frameInfos.size(); ++i) {
            const int frameTime = animatedImage->decodeNextFrame();
            REPORTER_ASSERT(r, frameTime == animatedImage->currentFrameDuration());
 
            if (i == frameInfos.size() - 1 && defaultRepetitionCount == 0) {
                REPORTER_ASSERT(r, frameTime == SkAnimatedImage::kFinished);
                REPORTER_ASSERT(r, animatedImage->isFinished());
            } else {
                REPORTER_ASSERT(r, frameTime == frameInfos[i].fDuration);
                REPORTER_ASSERT(r, !animatedImage->isFinished());
            }
 
            if (!testDraw(animatedImage, i)) {
                ERRORF(r, "Did not update to %zu properly", i);
                failed = true;
                break;
            }
        }
 
        if (failed) {
            continue;
        }
 
        animatedImage->reset();
        REPORTER_ASSERT(r, !animatedImage->isFinished());
        if (!testDraw(animatedImage, 0)) {
            ERRORF(r, "reset failed");
            continue;
        }
 
        // Test reset from all the frames.
        // j is the frame to call reset on.
        for (int j = 0; j < (int) frameInfos.size(); ++j) {
            if (failed) {
                break;
            }
 
            // i is the frame to decode.
            for (int i = 0; i <= j; ++i) {
                if (i == j) {
                    animatedImage->reset();
                    if (!testDraw(animatedImage, 0)) {
                        ERRORF(r, "reset failed for image %s from frame %i",
                                file, i);
                        failed = true;
                        break;
                    }
                } else if (i != 0) {
                    animatedImage->decodeNextFrame();
                    if (!testDraw(animatedImage, i)) {
                        ERRORF(r, "failed to match frame %i in %s on iteration %i",
                                i, file, j);
                        failed = true;
                        break;
                    }
                }
            }
        }
 
        if (failed) {
            continue;
        }
 
        for (int loopCount : { 0, 1, 2, 5 }) {
            animatedImage = SkAnimatedImage::Make(SkAndroidCodec::MakeFromCodec(
                        SkCodec::MakeFromData(data)));
            animatedImage->setRepetitionCount(loopCount);
            REPORTER_ASSERT(r, animatedImage->getRepetitionCount() == loopCount);
 
            for (int loops = 0; loops <= loopCount; loops++) {
                if (failed) {
                    break;
                }
                REPORTER_ASSERT(r, !animatedImage->isFinished());
                for (size_t i = 1; i <= frameInfos.size(); ++i) {
                    const int frameTime = animatedImage->decodeNextFrame();
                    if (frameTime == SkAnimatedImage::kFinished) {
                        if (loops != loopCount) {
                            ERRORF(r, "%s animation stopped early: loops: %i\tloopCount: %i",
                                    file, loops, loopCount);
                            failed = true;
                        }
                        if (i != frameInfos.size() - 1) {
                            ERRORF(r, "%s animation stopped early: i: %zu\tsize: %zu",
                                    file, i, frameInfos.size());
                            failed = true;
                        }
                        break;
                    }
                }
            }
 
            if (!animatedImage->isFinished()) {
                ERRORF(r, "%s animation should have finished with specified loop count (%i)",
                          file, loopCount);
            }
        }
    }
}