Add support for multiple frames in SkCodec

tests/CodecTest.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Resources.h"
 #include "SkAndroidCodec.h"
 #include "SkBitmap.h"
@@ skipping 272 matching lines @@
     SkMD5::Digest codecDigest;
     const SkImageInfo info = codec->getInfo().makeColorType(kN32_SkColorType);
     SkBitmap bm;
     SkCodec::Result expectedResult = isIncomplete ? SkCodec::kIncompleteInput : SkCodec::kSuccess;
     test_codec(r, codec.get(), bm, info, size, expectedResult, &codecDigest, nullptr);
 
     // Scanline decoding follows.
 
     if (supportsNewScanlineDecoding && !isIncomplete) {
         test_incremental_decode(r, codec, info, codecDigest);
-        test_in_stripes(r, codec, info, codecDigest);
+        // This is only supported by codecs that use incremental decoding to
+        // support subset decodes - png and jpeg (once SkJpegCodec is
+        // converted).
+        if (SkStrEndsWith(path, "png") || SkStrEndsWith(path, "PNG")) {
+            test_in_stripes(r, codec, info, codecDigest);
+        }
     }
 
     // Need to call startScanlineDecode() first.
     REPORTER_ASSERT(r, codec->getScanlines(bm.getAddr(0, 0), 1, 0) == 0);
     REPORTER_ASSERT(r, !codec->skipScanlines(1));
     const SkCodec::Result startResult = codec->startScanlineDecode(info);
     if (supportsScanlineDecoding) {
         bm.eraseColor(SK_ColorYELLOW);
 
         REPORTER_ASSERT(r, startResult == SkCodec::kSuccess);
@@ skipping 159 matching lines @@
 
     // ICO
     // FIXME: We are not ready to test incomplete ICOs
     // These two tests examine interestingly different behavior:
     // Decodes an embedded BMP image
     check(r, "color_wheel.ico", SkISize::Make(128, 128), true, false, false);
     // Decodes an embedded PNG image
     check(r, "google_chrome.ico", SkISize::Make(256, 256), false, false, false, true);
 
     // GIF
-    // FIXME: We are not ready to test incomplete GIFs
-    check(r, "box.gif", SkISize::Make(200, 55), true, false, false);
-    check(r, "color_wheel.gif", SkISize::Make(128, 128), true, false, false);
+    check(r, "box.gif", SkISize::Make(200, 55), false, false, true, true);
+    check(r, "color_wheel.gif", SkISize::Make(128, 128), false, false, true, true);
     // randPixels.gif is too small to test incomplete
-    check(r, "randPixels.gif", SkISize::Make(8, 8), true, false, false);
+    check(r, "randPixels.gif", SkISize::Make(8, 8), false, false, false, true);
 
     // JPG
     check(r, "CMYK.jpg", SkISize::Make(642, 516), true, false, true);
     check(r, "color_wheel.jpg", SkISize::Make(128, 128), true, false, true);
     // grayscale.jpg is too small to test incomplete
     check(r, "grayscale.jpg", SkISize::Make(128, 128), true, false, false);
     check(r, "mandrill_512_q075.jpg", SkISize::Make(512, 512), true, false, true);
     // randPixels.jpg is too small to test incomplete
     check(r, "randPixels.jpg", SkISize::Make(8, 8), true, false, false);
 
@@ skipping 723 matching lines @@
         REPORTER_ASSERT(r, SkCodec::kUnimplemented == result);
     }
 }
 
 DEF_TEST(Codec_F16ConversionPossible, r) {
     test_conversion_possible(r, "color_wheel.webp", false, false);
     test_conversion_possible(r, "mandrill_512_q075.jpg", true, false);
     test_conversion_possible(r, "yellow_rose.png", false, true);
 }
 
+static void decode_frame(skiatest::Reporter* r, SkCodec* codec, size_t frame) {
+    SkBitmap bm;
+    auto info = codec->getInfo().makeColorType(kN32_SkColorType);
+    bm.allocPixels(info);
+
+    SkCodec::Options opts;
+    SkCodec::MultiFrameOptions multiOpts;
+    multiOpts.fIndex = frame;
+    opts.fFrameOptions = &multiOpts;
+    REPORTER_ASSERT(r, SkCodec::kSuccess == codec->getPixels(info,
+            bm.getPixels(), bm.rowBytes(), &opts, nullptr, nullptr));
+}
+
+// For an animated image, we should only read enough to decode the requested
+// frame if the client never calls getFrameInfo.
+DEF_TEST(Codec_skipFullParse, r) {
+    auto path = "test640x479.gif";
+    SkStream* stream(GetResourceAsStream(path));
+    if (!stream) {
+        return;
+    }
+
+    // Note that we cheat and hold on to the stream pointer, but SkCodec will
+    // take ownership. We will not refer to the stream after the SkCodec
+    // deletes it.
+    std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream));
+    if (!codec) {
+        ERRORF(r, "Failed to create codec for %s", path);
+        return;
+    }
+
+    REPORTER_ASSERT(r, stream->hasPosition());
+    const size_t sizePosition = stream->getPosition();
+    REPORTER_ASSERT(r, stream->hasLength() && sizePosition < stream->getLength());
+
+    // This should read more of the stream, but not the whole stream.
+    decode_frame(r, codec.get(), 0);
+    const size_t positionAfterFirstFrame = stream->getPosition();
+    REPORTER_ASSERT(r, positionAfterFirstFrame > sizePosition
+                       && positionAfterFirstFrame < stream->getLength());
+
+    // Again, this should read more of the stream.
+    decode_frame(r, codec.get(), 2);
+    const size_t positionAfterThirdFrame = stream->getPosition();
+    REPORTER_ASSERT(r, positionAfterThirdFrame > positionAfterFirstFrame
+                       && positionAfterThirdFrame < stream->getLength());
+
+    // This does not need to read any more of the stream, since it has already
+    // parsed the second frame.
+    decode_frame(r, codec.get(), 1);
+    REPORTER_ASSERT(r, stream->getPosition() == positionAfterThirdFrame);
+
+    // This should read the rest of the frames.
+    decode_frame(r, codec.get(), 3);
+    const size_t finalPosition = stream->getPosition();
+    REPORTER_ASSERT(r, finalPosition > positionAfterThirdFrame);
+
+    // There may be more data in the stream.
+    auto frameInfo = codec->getFrameInfo();
+    REPORTER_ASSERT(r, frameInfo.size() == 4);
+    REPORTER_ASSERT(r, stream->getPosition() >= finalPosition);
+}
+
 // Only rewinds up to a limit.
 class LimitedRewindingStream : public SkStream {
 public:
     static SkStream* Make(const char path[], size_t limit) {
         SkStream* stream = GetResourceAsStream(path);
         if (!stream) {
             return nullptr;
         }
         return new LimitedRewindingStream(stream, limit);
     }
@@ skipping 31 matching lines @@
     }
 };
 
 DEF_TEST(Codec_fallBack, r) {
     // SkAndroidCodec needs to be able to fall back to scanline decoding
     // if incremental decoding does not work. Make sure this does not
     // require a rewind.
 
     // Formats that currently do not support incremental decoding
     auto files = {
-            "box.gif",
             "CMYK.jpg",
             "color_wheel.ico",
             "mandrill.wbmp",
             "randPixels.bmp",
             };
     for (auto file : files) {
         SkStream* stream = LimitedRewindingStream::Make(file, 14);
         if (!stream) {
             SkDebugf("Missing resources (%s). Set --resourcePath.\n", file);
             return;
@@ skipping 81 matching lines @@
     REPORTER_ASSERT(r, result == SkCodec::kIncompleteInput);
     REPORTER_ASSERT(r, rowsDecoded == 0);
 }
 
 DEF_TEST(Codec_IcoIntOverflow, r) {
     // ASAN will complain if there is an issue.
     SkBitmap bitmap;
     const bool success = GetResourceAsBitmap("invalid_images/int_overflow.ico", &bitmap);
     REPORTER_ASSERT(r, !success);
 }