Add animation support for WebP images

Source/WebKit/chromium/tests/WEBPImageDecoderTest.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 12 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
-#include "GIFImageDecoder.h"
+#include "WEBPImageDecoder.h"
 
 #include "FileSystem.h"
 #include "SharedBuffer.h"
+#include <base/basictypes.h>
 #include <gtest/gtest.h>
 #include <public/Platform.h>
 #include <public/WebData.h>
 #include <public/WebSize.h>
 #include <public/WebUnitTestSupport.h>
 #include <wtf/OwnPtr.h>
 #include <wtf/PassOwnPtr.h>
 #include <wtf/StringHasher.h>
 #include <wtf/Vector.h>
 
@@ skipping 14 matching lines @@
         return 0;
 
     PlatformFileHandle handle = openFile(filePath, OpenForRead);
     int fileLength = static_cast<int>(fileSize);
     Vector<char> buffer(fileLength);
     readFromFile(handle, buffer.data(), fileLength);
     closeFile(handle);
     return SharedBuffer::adoptVector(buffer);
 }
 
-static PassOwnPtr<GIFImageDecoder> createDecoder()
+static PassOwnPtr<WEBPImageDecoder> createDecoder()
 {
-    return adoptPtr(new GIFImageDecoder(ImageSource::AlphaNotPremultiplied, ImageSource::GammaAndColorProfileApplied));
+    return adoptPtr(new WEBPImageDecoder(ImageSource::AlphaNotPremultiplied, ImageSource::GammaAndColorProfileApplied));
 }
 
 static unsigned hashSkBitmap(const SkBitmap& bitmap)
 {
     return StringHasher::hashMemory(bitmap.getPixels(), bitmap.getSize());
 }
 
-TEST(GIFImageDecoderTest, decodeTwoFrames)
+TEST(WEBPImageDecoderTest, verifyAnimationParameters)

[Alpha Left Google, 2013/04/25 22:07:12]

You can have these as TEST_F such that enabling animated WebP is done for all
tests in this file.

[urvang (Google), 2013/04/26 01:46:23]

Done.

 {
-    OwnPtr<GIFImageDecoder> decoder(createDecoder());
+    OwnPtr<WEBPImageDecoder> decoder(createDecoder());
+    EXPECT_EQ(cAnimationLoopOnce, decoder->repetitionCount());
 
-    RefPtr<SharedBuffer> data = readFile("/LayoutTests/fast/images/resources/animated.gif");
+    RefPtr<SharedBuffer> data = readFile("/LayoutTests/fast/images/resources/webp-animated.webp");
     ASSERT_TRUE(data.get());
     decoder->setData(data.get(), true);
-    EXPECT_EQ(cAnimationLoopOnce, decoder->repetitionCount());
 
-    ImageFrame* frame = decoder->frameBufferAtIndex(0);
-    EXPECT_EQ(ImageFrame::FrameComplete, frame->status());
-    EXPECT_EQ(16, frame->getSkBitmap().width());
-    EXPECT_EQ(16, frame->getSkBitmap().height());
+    const int canvasWidth = 11;
+    const int canvasHeight = 29;
+    const int hasAlpha = true;
+    const struct AnimParam {
+        int xOffset, yOffset, width, height;
+        ImageFrame::FrameDisposalMethod dispose;
+        unsigned duration;
+    } animParams[] = {
+        { 0, 0, 11, 29, ImageFrame::DisposeKeep, 1000u },
+        { 2, 10, 7, 17, ImageFrame::DisposeKeep, 500u },
+        { 2, 2, 7, 16, ImageFrame::DisposeKeep, 1000u },
+    };
 
-    frame = decoder->frameBufferAtIndex(1);
-    EXPECT_EQ(ImageFrame::FrameComplete, frame->status());
-    EXPECT_EQ(16, frame->getSkBitmap().width());
-    EXPECT_EQ(16, frame->getSkBitmap().height());
+    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(animParams); ++i) {
+        const ImageFrame* const frame = decoder->frameBufferAtIndex(i);
+        EXPECT_EQ(ImageFrame::FrameComplete, frame->status());
+        EXPECT_EQ(canvasWidth, frame->getSkBitmap().width());
+        EXPECT_EQ(canvasHeight, frame->getSkBitmap().height());
+        EXPECT_EQ(hasAlpha, frame->hasAlpha());
+        EXPECT_EQ(animParams[i].xOffset, frame->originalFrameRect().x());
+        EXPECT_EQ(animParams[i].yOffset, frame->originalFrameRect().y());
+        EXPECT_EQ(animParams[i].width, frame->originalFrameRect().width());
+        EXPECT_EQ(animParams[i].height, frame->originalFrameRect().height());
+        EXPECT_EQ(animParams[i].dispose, frame->disposalMethod());
+        EXPECT_EQ(animParams[i].duration, frame->duration());
+    }
 
-    EXPECT_EQ(2u, decoder->frameCount());
+    EXPECT_EQ(ARRAYSIZE_UNSAFE(animParams), decoder->frameCount());
     EXPECT_EQ(cAnimationLoopInfinite, decoder->repetitionCount());
 }
 
-TEST(GIFImageDecoderTest, parseAndDecode)
+TEST(WEBPImageDecoderTest, parseAndDecodeByteByByte)
 {
-    OwnPtr<GIFImageDecoder> decoder(createDecoder());
+    const struct TestImage {
+        const char* filename;
+        unsigned frameCount;
+        int repetitionCount;
+    } testImages[] = {
+        { "/LayoutTests/fast/images/resources/webp-animated.webp", 3u, cAnimationLoopInfinite },
+        { "/LayoutTests/fast/images/resources/webp-animated-icc-xmp.webp", 13u, 32000 },
+    };
 
-    RefPtr<SharedBuffer> data = readFile("/LayoutTests/fast/images/resources/animated.gif");
-    ASSERT_TRUE(data.get());
-    decoder->setData(data.get(), true);
-    EXPECT_EQ(cAnimationLoopOnce, decoder->repetitionCount());
+    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(testImages); ++i) {
+        OwnPtr<WEBPImageDecoder> decoder(createDecoder());
+        RefPtr<SharedBuffer> data = readFile(testImages[i].filename);
+        ASSERT_TRUE(data.get());
 
-    // This call will parse the entire file.
-    EXPECT_EQ(2u, decoder->frameCount());
+        size_t frameCount = 0;
+        size_t framesDecoded = 0;
 
-    ImageFrame* frame = decoder->frameBufferAtIndex(0);
-    EXPECT_EQ(ImageFrame::FrameComplete, frame->status());
-    EXPECT_EQ(16, frame->getSkBitmap().width());
-    EXPECT_EQ(16, frame->getSkBitmap().height());
+        // Pass data to decoder byte by byte.
+        for (unsigned length = 1; length <= data->size(); ++length) {
+            RefPtr<SharedBuffer> tempData = SharedBuffer::create(data->data(), length);
+            decoder->setData(tempData.get(), length == data->size());
 
-    frame = decoder->frameBufferAtIndex(1);
-    EXPECT_EQ(ImageFrame::FrameComplete, frame->status());
-    EXPECT_EQ(16, frame->getSkBitmap().width());
-    EXPECT_EQ(16, frame->getSkBitmap().height());
-    EXPECT_EQ(cAnimationLoopInfinite, decoder->repetitionCount());
+            EXPECT_LE(frameCount, decoder->frameCount());
+            frameCount = decoder->frameCount();
+
+            ImageFrame* frame = decoder->frameBufferAtIndex(frameCount - 1);
+            if (frame && frame->status() == ImageFrame::FrameComplete && framesDecoded < frameCount)
+                ++framesDecoded;
+        }
+
+        EXPECT_EQ(testImages[i].frameCount, decoder->frameCount());
+        EXPECT_EQ(testImages[i].frameCount, framesDecoded);
+        EXPECT_EQ(testImages[i].repetitionCount, decoder->repetitionCount());
+    }
 }
 
-TEST(GIFImageDecoderTest, parseByteByByte)
+TEST(WEBPImageDecoderTest, invalidImage)
 {
-    OwnPtr<GIFImageDecoder> decoder(createDecoder());
+    OwnPtr<WEBPImageDecoder> decoder(createDecoder());
 
-    RefPtr<SharedBuffer> data = readFile("/LayoutTests/fast/images/resources/animated.gif");
-    ASSERT_TRUE(data.get());
-
-    size_t frameCount = 0;
-
-    // Pass data to decoder byte by byte.
-    for (unsigned length = 1; length <= data->size(); ++length) {
-        RefPtr<SharedBuffer> tempData = SharedBuffer::create(data->data(), length);
-        decoder->setData(tempData.get(), length == data->size());
-
-        EXPECT_LE(frameCount, decoder->frameCount());
-        frameCount = decoder->frameCount();
-    }
-
-    EXPECT_EQ(2u, decoder->frameCount());
-
-    decoder->frameBufferAtIndex(0);
-    decoder->frameBufferAtIndex(1);
-    EXPECT_EQ(cAnimationLoopInfinite, decoder->repetitionCount());
-}
-
-TEST(GIFImageDecoderTest, parseAndDecodeByteByByte)
-{
-    OwnPtr<GIFImageDecoder> decoder(createDecoder());
-
-    RefPtr<SharedBuffer> data = readFile("/LayoutTests/fast/images/resources/animated-gif-with-offsets.gif");
-    ASSERT_TRUE(data.get());
-
-    size_t frameCount = 0;
-    size_t framesDecoded = 0;
-
-    // Pass data to decoder byte by byte.
-    for (unsigned length = 1; length <= data->size(); ++length) {
-        RefPtr<SharedBuffer> tempData = SharedBuffer::create(data->data(), length);
-        decoder->setData(tempData.get(), length == data->size());
-
-        EXPECT_LE(frameCount, decoder->frameCount());
-        frameCount = decoder->frameCount();
-
-        ImageFrame* frame = decoder->frameBufferAtIndex(frameCount - 1);
-        if (frame && frame->status() == ImageFrame::FrameComplete && framesDecoded < frameCount)
-            ++framesDecoded;
-    }
-
-    EXPECT_EQ(5u, decoder->frameCount());
-    EXPECT_EQ(5u, framesDecoded);
-    EXPECT_EQ(cAnimationLoopInfinite, decoder->repetitionCount());
-}
-
-TEST(GIFImageDecoderTest, brokenSecondFrame)
-{
-    OwnPtr<GIFImageDecoder> decoder(createDecoder());
-
-    RefPtr<SharedBuffer> data = readFile("/Source/WebKit/chromium/tests/data/broken.gif");
+    RefPtr<SharedBuffer> data = readFile("/LayoutTests/fast/images/resources/invalid-animated-webp.webp");
     ASSERT_TRUE(data.get());
     decoder->setData(data.get(), true);
 
     EXPECT_EQ(0u, decoder->frameCount());
     ImageFrame* frame = decoder->frameBufferAtIndex(0);
     EXPECT_FALSE(frame);
     EXPECT_EQ(cAnimationLoopOnce, decoder->repetitionCount());
 }
 
-TEST(GIFImageDecoderTest, progressiveDecode)
+TEST(WEBPImageDecoderTest, progressiveDecode)
 {
-    RefPtr<SharedBuffer> fullData = readFile("/Source/WebKit/chromium/tests/data/radient.gif");
+    RefPtr<SharedBuffer> fullData = readFile("/LayoutTests/fast/images/resources/webp-animated.webp");
     ASSERT_TRUE(fullData.get());
     const size_t fullLength = fullData->size();
 
-    OwnPtr<GIFImageDecoder> decoder;
+    OwnPtr<WEBPImageDecoder>  decoder;
     ImageFrame* frame;
 
     Vector<unsigned> truncatedHashes;
     Vector<unsigned> progressiveHashes;
 
     // Compute hashes when the file is truncated.
     const size_t increment = 1;
     for (size_t i = 1; i <= fullLength; i += increment) {
         decoder = createDecoder();
         RefPtr<SharedBuffer> data = SharedBuffer::create(fullData->data(), i);
@@ skipping 25 matching lines @@
             match = false;
             break;
         }
     }
     EXPECT_TRUE(match);
 }
 
 #endif
 
 } // namespace