Deferred image decoding to support animated GIFs

Source/core/platform/graphics/chromium/ImageFrameGenerator.cpp

 /*
  * Copyright (C) 2012 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 29 matching lines @@
 
 namespace {
 
 skia::ImageOperations::ResizeMethod resizeMethod()
 {
     return skia::ImageOperations::RESIZE_LANCZOS3;
 }
 
 } // namespace
 
-ImageFrameGenerator::ImageFrameGenerator(const SkISize& fullSize, PassRefPtr<SharedBuffer> data, bool allDataReceived)
+ImageFrameGenerator::ImageFrameGenerator(const SkISize& fullSize, PassRefPtr<SharedBuffer> data, bool allDataReceived, bool isMultiFrame)
     : m_fullSize(fullSize)
+    , m_isMultiFrame(isMultiFrame)
     , m_decodeFailedAndEmpty(false)
     , m_hasAlpha(true)
     , m_decodeCount(ScaledImageFragment::FirstPartialImage)
 {
     setData(data.get(), allDataReceived);
 }
 
 ImageFrameGenerator::~ImageFrameGenerator()
 {
     // FIXME: This check is not really thread-safe. This should be changed to:
     // ImageDecodingStore::removeCacheFromInstance(this);
     // Which uses a lock internally.
     if (ImageDecodingStore::instance())
         ImageDecodingStore::instance()->removeCacheIndexedByGenerator(this);
 }
 
 void ImageFrameGenerator::setData(PassRefPtr<SharedBuffer> data, bool allDataReceived)
 {
     m_data.setData(data.get(), allDataReceived);
 }
 
 void ImageFrameGenerator::copyData(RefPtr<SharedBuffer>* data, bool* allDataReceived)
 {
     SharedBuffer* buffer = 0;
     m_data.data(&buffer, allDataReceived);
     if (buffer)
         *data = buffer->copy();
 }
 
-const ScaledImageFragment* ImageFrameGenerator::decodeAndScale(const SkISize& scaledSize)
+const ScaledImageFragment* ImageFrameGenerator::decodeAndScale(const SkISize& scaledSize, size_t index)
 {
     // Prevents concurrent decode or scale operations on the same image data.
     // Multiple LazyDecodingPixelRefs can call this method at the same time.
     MutexLocker lock(m_decodeMutex);
     if (m_decodeFailedAndEmpty)
         return 0;
 
     const ScaledImageFragment* cachedImage = 0;
 
-    cachedImage = tryToLockCompleteCache(scaledSize);
+    cachedImage = tryToLockCompleteCache(scaledSize, index);
     if (cachedImage)
         return cachedImage;
 
     TRACE_EVENT2("webkit", "ImageFrameGenerator::decodeAndScale", "generator", this, "decodeCount", static_cast<int>(m_decodeCount));
 
-    cachedImage = tryToScale(0, scaledSize);
+    cachedImage = tryToScale(0, scaledSize, index);
     if (cachedImage)
         return cachedImage;
 
-    cachedImage = tryToResumeDecodeAndScale(scaledSize);
+    cachedImage = tryToResumeDecodeAndScale(scaledSize, index);
     if (cachedImage)
         return cachedImage;
 
-    cachedImage = tryToDecodeAndScale(scaledSize);
+    cachedImage = tryToDecodeAndScale(scaledSize, index);
     if (cachedImage)
         return cachedImage;
     return 0;
 }
 
-const ScaledImageFragment* ImageFrameGenerator::tryToLockCompleteCache(const SkISize& scaledSize)
+const ScaledImageFragment* ImageFrameGenerator::tryToLockCompleteCache(const SkISize& scaledSize, size_t index)
 {
     const ScaledImageFragment* cachedImage = 0;
-    if (ImageDecodingStore::instance()->lockCache(this, scaledSize, 0, &cachedImage))
+    if (ImageDecodingStore::instance()->lockCache(this, scaledSize, index, &cachedImage))
         return cachedImage;
     return 0;
 }
 
-const ScaledImageFragment* ImageFrameGenerator::tryToScale(const ScaledImageFragment* fullSizeImage, const SkISize& scaledSize)
+const ScaledImageFragment* ImageFrameGenerator::tryToScale(const ScaledImageFragment* fullSizeImage, const SkISize& scaledSize, size_t index)
 {
     TRACE_EVENT0("webkit", "ImageFrameGenerator::tryToScale");
 
     // If the requested scaled size is the same as the full size then exit
     // early. This saves a cache lookup.
     if (scaledSize == m_fullSize)
         return 0;
 
-    if (!fullSizeImage && !ImageDecodingStore::instance()->lockCache(this, m_fullSize, 0, &fullSizeImage))
+    if (!fullSizeImage && !ImageDecodingStore::instance()->lockCache(this, m_fullSize, index, &fullSizeImage))
         return 0;
 
     // This call allocates the DiscardablePixelRef and lock/unlocks it
     // afterwards. So the memory allocated to the scaledBitmap can be
     // discarded after this call. Need to lock the scaledBitmap and
     // check the pixels before using it next time.
     SkBitmap scaledBitmap = skia::ImageOperations::Resize(fullSizeImage->bitmap(), resizeMethod(), scaledSize.width(), scaledSize.height(), &m_allocator);
 
     OwnPtr<ScaledImageFragment> scaledImage;
     if (fullSizeImage->isComplete())
         scaledImage = ScaledImageFragment::createComplete(scaledSize, fullSizeImage->index(), scaledBitmap);
     else
         scaledImage = ScaledImageFragment::createPartial(scaledSize, fullSizeImage->index(), nextGenerationId(), scaledBitmap);
     ImageDecodingStore::instance()->unlockCache(this, fullSizeImage);
     return ImageDecodingStore::instance()->insertAndLockCache(this, scaledImage.release());
 }
 
-const ScaledImageFragment* ImageFrameGenerator::tryToResumeDecodeAndScale(const SkISize& scaledSize)
+const ScaledImageFragment* ImageFrameGenerator::tryToResumeDecodeAndScale(const SkISize& scaledSize, size_t index)
 {
-    TRACE_EVENT0("webkit", "ImageFrameGenerator::tryToResumeDecodeAndScale");
+    TRACE_EVENT1("webkit", "ImageFrameGenerator::tryToResumeDecodeAndScale", "index", static_cast<int>(index));
 
     ImageDecoder* cachedDecoder = 0;
 
     if (!ImageDecodingStore::instance()->lockDecoder(this, m_fullSize, &cachedDecoder))
         return 0;
     ASSERT(cachedDecoder);
 
     // Always generate a new image and insert it into cache.
-    OwnPtr<ScaledImageFragment> fullSizeImage = decode(&cachedDecoder);
+    OwnPtr<ScaledImageFragment> fullSizeImage = decode(index, &cachedDecoder);
     const ScaledImageFragment* cachedImage = ImageDecodingStore::instance()->insertAndLockCache(this, fullSizeImage.release());
 
     // If the image generated is complete then there is no need to keep
-    // the decoder.
-    if (cachedImage->isComplete())
+    // the decoder. The exception is multi-frame decoder which can generate
+    // multiple complete frames.
+    if (cachedImage->isComplete() && !m_isMultiFrame)
         ImageDecodingStore::instance()->removeDecoder(this, cachedDecoder);
     else
         ImageDecodingStore::instance()->unlockDecoder(this, cachedDecoder);
 
     if (m_fullSize == scaledSize)
         return cachedImage;
-    return tryToScale(cachedImage, scaledSize);
+    return tryToScale(cachedImage, scaledSize, index);
 }
 
-const ScaledImageFragment* ImageFrameGenerator::tryToDecodeAndScale(const SkISize& scaledSize)
+const ScaledImageFragment* ImageFrameGenerator::tryToDecodeAndScale(const SkISize& scaledSize, size_t index)
 {
-    TRACE_EVENT0("webkit", "ImageFrameGenerator::tryToDecodeAndScale");
+    TRACE_EVENT1("webkit", "ImageFrameGenerator::tryToDecodeAndScale", "index", static_cast<int>(index));
 
     ImageDecoder* decoder = 0;
-    OwnPtr<ScaledImageFragment> fullSizeImage = decode(&decoder);
+    OwnPtr<ScaledImageFragment> fullSizeImage = decode(index, &decoder);
 
     if (!decoder)
         return 0;
 
     OwnPtr<ImageDecoder> decoderContainer = adoptPtr(decoder);
 
     if (!fullSizeImage) {
         // If decode has failed and resulted an empty image we need to make
         // sure we don't do wasted work in the future.
         m_decodeFailedAndEmpty = decoderContainer->failed();
         return 0;
     }
 
     const ScaledImageFragment* cachedImage = ImageDecodingStore::instance()->insertAndLockCache(this, fullSizeImage.release());
 
     // If image is complete then decoder is not needed in the future.
-    // Otherwise save the decoder for later use.
-    if (!cachedImage->isComplete())
+    // Otherwise save the decoder for later use. The exception is
+    // multi-frame decoder which can generate multiple complete frames.
+    if (!cachedImage->isComplete() || m_isMultiFrame)
         ImageDecodingStore::instance()->insertDecoder(this, decoderContainer.release(), DiscardablePixelRef::isDiscardable(cachedImage->bitmap().pixelRef()));
 
     if (m_fullSize == scaledSize)
         return cachedImage;
-    return tryToScale(cachedImage, scaledSize);
+    return tryToScale(cachedImage, scaledSize, index);
 }
 
-PassOwnPtr<ScaledImageFragment> ImageFrameGenerator::decode(ImageDecoder** decoder)
+PassOwnPtr<ScaledImageFragment> ImageFrameGenerator::decode(size_t index, ImageDecoder** decoder)
 {
     TRACE_EVENT2("webkit", "ImageFrameGenerator::decode", "width", m_fullSize.width(), "height", m_fullSize.height());
 
     ASSERT(decoder);
     SharedBuffer* data = 0;
     bool allDataReceived = false;
     m_data.data(&data, &allDataReceived);
 
     // Try to create an ImageDecoder if we are not given one.
     if (!*decoder) {
         *decoder = ImageDecoder::create(*data, ImageSource::AlphaPremultiplied, ImageSource::GammaAndColorProfileApplied).leakPtr();
 
         if (!*decoder && m_imageDecoderFactory)
             *decoder = m_imageDecoderFactory->create().leakPtr();
 
         if (!*decoder)
             return nullptr;
     }
 
     // TODO: this is very ugly. We need to refactor the way how we can pass a
     // memory allocator to image decoders.
-    (*decoder)->setMemoryAllocator(&m_allocator);
+    if (!m_isMultiFrame)
+        (*decoder)->setMemoryAllocator(&m_allocator);
     (*decoder)->setData(data, allDataReceived);
     // If this call returns a newly allocated DiscardablePixelRef, then
     // ImageFrame::m_bitmap and the contained DiscardablePixelRef are locked.
     // They will be unlocked when ImageDecoder is destroyed since ImageDecoder
     // owns the ImageFrame. Partially decoded SkBitmap is thus inserted into the
     // ImageDecodingStore while locked.
-    ImageFrame* frame = (*decoder)->frameBufferAtIndex(0);
+    ImageFrame* frame = (*decoder)->frameBufferAtIndex(index);
     (*decoder)->setData(0, false); // Unref SharedBuffer from ImageDecoder.
+    (*decoder)->clearCacheExceptFrame(index);
 
     if (!frame || frame->status() == ImageFrame::FrameEmpty)
         return nullptr;
 
     const bool isComplete = frame->status() == ImageFrame::FrameComplete;
     SkBitmap fullSizeBitmap = frame->getSkBitmap();
     {
         MutexLocker lock(m_alphaMutex);
         m_hasAlpha = !fullSizeBitmap.isOpaque();
     }
     ASSERT(fullSizeBitmap.width() == m_fullSize.width() && fullSizeBitmap.height() == m_fullSize.height());
 
     if (isComplete)
-        return ScaledImageFragment::createComplete(m_fullSize, 0, fullSizeBitmap);
+        return ScaledImageFragment::createComplete(m_fullSize, index, fullSizeBitmap);
 
     // If the image is partial we need to return a copy. This is to avoid future
     // decode operations writing to the same bitmap.
     SkBitmap copyBitmap;
     fullSizeBitmap.copyTo(&copyBitmap, fullSizeBitmap.config(), &m_allocator);
-    return ScaledImageFragment::createPartial(m_fullSize, 0, nextGenerationId(), copyBitmap);
+    return ScaledImageFragment::createPartial(m_fullSize, index, nextGenerationId(), copyBitmap);
 }
 
 bool ImageFrameGenerator::hasAlpha()
 {
     MutexLocker lock(m_alphaMutex);
     return m_hasAlpha;
 }
 
 } // namespace WebCore