GIF decoding to Index8, unit tests and misusing unit test as benchmark

third_party/WebKit/Source/platform/graphics/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 90 matching lines @@
 }
 
 ImageFrameGenerator::ImageFrameGenerator(const SkISize& fullSize, PassRefPtr<SharedBuffer> data, bool allDataReceived, bool isMultiFrame)
     : m_fullSize(fullSize)
     , m_data(adoptRef(new ThreadSafeDataTransport()))
     , m_isMultiFrame(isMultiFrame)
     , m_decodeFailedAndEmpty(false)
     , m_decodeCount(0)
     , m_frameCount(0)
     , m_encodedData(nullptr)
+    , m_decoderCanDecodeToIndex8(false)
 {
     setData(data.get(), allDataReceived);
 }
 
 ImageFrameGenerator::~ImageFrameGenerator()
 {
     if (m_encodedData)
         m_encodedData->unref();
     ImageDecodingStore::instance().removeCacheIndexedByGenerator(this);
 }
@@ skipping 47 matching lines @@
         // While m_encodedData is referenced, prevent disposing m_data and its content.
         // it is dereferenced in sharedSkDataReleaseCallback, called when m_encodedData gets dereferenced.
         m_data->ref();
     }
     // Increase the reference, caller must decrease it. One reference is always kept by ImageFrameGenerator and released
     // in destructor.
     m_encodedData->ref();
     return m_encodedData;
 }
 
-bool ImageFrameGenerator::decodeAndScale(const SkImageInfo& info, size_t index, void* pixels, size_t rowBytes)
+static bool copyIndex8PixelsTo(const SkBitmap& bitmap, const SkImageInfo& info, void* pixels, size_t rowBytes)
+{
+    // This method is called for GIF animations, only for frames that, in first animation loop, get
+    // decoded to N32, but then are decoded to Index8 in later animation loop. It is needed to return
+    // N32 pixels but internally GIF decoder produces and caches Index8 bitmap.
+    if (bitmap.colorType() != kIndex_8_SkColorType)
+        return false;
+    // GIF decoder always produce colortable with 256 entries.
+    ASSERT(bitmap.getColorTable() && bitmap.getColorTable()->count() == 256);
+
+    const SkPMColor* colors = bitmap.getColorTable()->readColors();
+    uint8_t* destination8 = (uint8_t*)pixels;
+    for (int j = 0; j < bitmap.height(); ++j) {
+        uint32_t* destination32 = (uint32_t*)destination8;
+        const uint8_t* source = bitmap.getAddr8(0, j);
+        const uint8_t* sourceEnd = source + bitmap.width();
+        while (source != sourceEnd)
+            *destination32++ = colors[*source++];
+        destination8 += rowBytes;
+    }
+    return true;
+}
+
+bool ImageFrameGenerator::decodeAndScale(const SkImageInfo& info, size_t index, void* pixels, size_t rowBytes, SkPMColor ctable[], int* ctableCount)
 {
     // This method is called to populate a discardable memory owned by Skia.
 
     // Prevents concurrent decode or scale operations on the same image data.
     MutexLocker lock(m_decodeMutex);
 
     // This implementation does not support scaling so check the requested size.
     SkISize scaledSize = SkISize::Make(info.width(), info.height());
     ASSERT(m_fullSize == scaledSize);
 
     if (m_decodeFailedAndEmpty)
         return false;
 
     TRACE_EVENT2("blink", "ImageFrameGenerator::decodeAndScale", "generator", this, "decodeCount", m_decodeCount);
 
     m_externalAllocator = adoptPtr(new ExternalMemoryAllocator(info, pixels, rowBytes));
 
-    SkBitmap bitmap = tryToResumeDecode(scaledSize, index);
+    SkBitmap bitmap = tryToResumeDecode(scaledSize, index, info.colorType());
     if (bitmap.isNull())
         return false;
 
     // Don't keep the allocator because it contains a pointer to memory
     // that we do not own.
     m_externalAllocator.clear();
 
     ASSERT(bitmap.width() == scaledSize.width());
     ASSERT(bitmap.height() == scaledSize.height());
 
+    // If decoder cannot produce requested color type, return false.
+    if (bitmap.colorType() != info.colorType() && bitmap.colorType() != kIndex_8_SkColorType)
+        return false;
+
     bool result = true;
     SkAutoLockPixels bitmapLock(bitmap);
     // Check to see if decoder has written directly to the memory provided
     // by Skia. If not make a copy.
-    if (bitmap.getPixels() != pixels)
-        result = bitmap.copyPixelsTo(pixels, rowBytes * info.height(), rowBytes);
+    if (bitmap.getPixels() != pixels) {
+        if (bitmap.colorType() == info.colorType()) {
+            result = bitmap.copyPixelsTo(pixels, rowBytes * info.height(), rowBytes);
+        } else {
+            ASSERT(bitmap.colorType() == kIndex_8_SkColorType && info.colorType() == kN32_SkColorType);
+            result = copyIndex8PixelsTo(bitmap, info, pixels, rowBytes);
+        }
+    }
+    if (info.colorType() == kIndex_8_SkColorType && ctable && bitmap.getColorTable()) {
+        memcpy(ctable, bitmap.getColorTable()->readColors(), bitmap.getColorTable()->count() * sizeof(SkPMColor));
+    }
+    if (ctableCount) {
+        // Based on SkImageGenerator API spec, ctableCount needs to be set to 0 for other types.
+        *ctableCount = (info.colorType() == kIndex_8_SkColorType && bitmap.getColorTable())
+            ? bitmap.getColorTable()->count()
+            : 0;
+    }
     return result;
 }
 
 bool ImageFrameGenerator::decodeToYUV(SkISize componentSizes[3], void* planes[3], size_t rowBytes[3])
 {
     // This method is called to populate a discardable memory owned by Skia.
 
     // Prevents concurrent decode or scale operations on the same image data.
     MutexLocker lock(m_decodeMutex);
 
@@ skipping 25 matching lines @@
 
     bool sizeUpdated = updateYUVComponentSizes(decoder.get(), componentSizes, ImageDecoder::ActualSize);
     RELEASE_ASSERT(sizeUpdated);
 
     bool yuvDecoded = decoder->decodeToYUV();
     if (yuvDecoded)
         setHasAlpha(0, false); // YUV is always opaque
     return yuvDecoded;
 }
 
-SkBitmap ImageFrameGenerator::tryToResumeDecode(const SkISize& scaledSize, size_t index)
+SkBitmap ImageFrameGenerator::tryToResumeDecode(const SkISize& scaledSize, size_t index, SkColorType outputColor)

[aleksandar.stojiljkovic, 2016/01/18 13:58:49]

 SkColorType outputColor is not necessary. Removed.

 {
     TRACE_EVENT1("blink", "ImageFrameGenerator::tryToResumeDecodeAndScale", "index", static_cast<int>(index));
 
     ImageDecoder* decoder = 0;
     const bool resumeDecoding = ImageDecodingStore::instance().lockDecoder(this, m_fullSize, &decoder);
     ASSERT(!resumeDecoding || decoder);
 
     SkBitmap fullSizeImage;
-    bool complete = decode(index, &decoder, &fullSizeImage);
+    bool complete = decode(index, &decoder, &fullSizeImage, outputColor);
 
     if (!decoder)
         return SkBitmap();
     if (index >= m_frameComplete.size())
         m_frameComplete.resize(index + 1);
     m_frameComplete[index] = complete;
 
     // If we are not resuming decoding that means the decoder is freshly
     // created and we have ownership. If we are resuming decoding then
     // the decoder is owned by ImageDecodingStore.
@@ skipping 45 matching lines @@
     MutexLocker lock(m_alphaMutex);
     if (index >= m_hasAlpha.size()) {
         const size_t oldSize = m_hasAlpha.size();
         m_hasAlpha.resize(index + 1);
         for (size_t i = oldSize; i < m_hasAlpha.size(); ++i)
             m_hasAlpha[i] = true;
     }
     m_hasAlpha[index] = hasAlpha;
 }
 
-bool ImageFrameGenerator::decode(size_t index, ImageDecoder** decoder, SkBitmap* bitmap)
+bool ImageFrameGenerator::decode(size_t index, ImageDecoder** decoder, SkBitmap* bitmap, SkColorType outputColor)
 {
     TRACE_EVENT2("blink", "ImageFrameGenerator::decode", "width", m_fullSize.width(), "height", m_fullSize.height());
 
     ASSERT(decoder);
     SharedBuffer* data = 0;
     bool allDataReceived = false;
     bool newDecoder = false;
     m_data->data(&data, &allDataReceived);
 
     // Try to create an ImageDecoder if we are not given one.
@@ skipping 73 matching lines @@
         return false;
 
     // Setting a dummy ImagePlanes object signals to the decoder that we want to do YUV decoding.
     decoder->setData(data, allDataReceived);
     OwnPtr<ImagePlanes> dummyImagePlanes = adoptPtr(new ImagePlanes);
     decoder->setImagePlanes(dummyImagePlanes.release());
 
     return updateYUVComponentSizes(decoder.get(), componentSizes, ImageDecoder::SizeForMemoryAllocation);
 }
 
+bool ImageFrameGenerator::canDecodeTo(size_t index, SkColorType outputType)
+{
+    if (m_decoderCanDecodeToIndex8) {
+        // Prevents concurrent decode or scale operations on the same image data.
+        MutexLocker lock(m_decodeMutex);
+        ImageDecoder* decoder = 0;
+        const bool decoderExist = ImageDecodingStore::instance().lockDecoder(this, m_fullSize, &decoder);
+        ASSERT(!decoderExist || decoder);
+        SharedBuffer* data = 0;
+        bool allDataReceived = false;
+        m_data->data(&data, &allDataReceived);
+        if (!decoderExist) {
+            if (m_imageDecoderFactory)
+                decoder = m_imageDecoderFactory->create().leakPtr();
+            if (!decoder)
+                decoder = ImageDecoder::create(*data, ImageDecoder::AlphaPremultiplied, ImageDecoder::GammaAndColorProfileApplied).leakPtr();
+            if (!decoder)
+                return (outputType == kIndex_8_SkColorType);
+        }
+        decoder->setData(data, allDataReceived);
+        bool canDecodeToIndex8 = decoder->canDecodeTo(index, static_cast<ImageFrame::ColorType>(outputType));
+        decoder->setData(0, false); // Unref SharedBuffer from ImageDecoder.
+        if (decoderExist) {
+            ImageDecodingStore::instance().unlockDecoder(this, decoder);
+        } else {
+            ImageDecodingStore::instance().insertDecoder(this, PassOwnPtr<blink::ImageDecoder>(adoptPtr(decoder)));
+        }
+        return (canDecodeToIndex8 && (outputType == kIndex_8_SkColorType));
+    }
+    return (outputType == kN32_SkColorType);

[scroggo_chromium, 2016/01/06 21:50:40]

Would it make more sense to put this at the beginning of the method?

[aleksandar.stojiljkovic, 2016/01/18 13:58:49]

Done.

+}
+
+
 } // namespace blink