JPEGImageDecoder RGB565 and downsample support and related Skia imagegenerator changes

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 114 matching lines @@
         *data = buffer->copy();
 }
 
 bool ImageFrameGenerator::decodeAndScale(const SkImageInfo& info, size_t index, void* pixels, size_t rowBytes)
 {
     // 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);
+    SkISize outputSize = SkISize::Make(info.width(), info.height());
 
     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);
-    if (bitmap.isNull())
-        return false;
+    SkBitmap bitmap = tryToResumeDecode(outputSize, index, info.colorType(), rowBytes);
 
     // 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 (bitmap.isNull())
+        return false;
+
+    ASSERT(bitmap.width() == outputSize.width());
+    ASSERT(bitmap.height() == outputSize.height());
 
     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);
     return result;
 }
 
@@ skipping 32 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& outputSize, size_t index, SkColorType outputType, size_t rowBytes)
 {
     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);
+    SkBitmap image;
+    bool complete = decode(index, &decoder, &image, outputType, outputSize, rowBytes);
 
     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.
     OwnPtr<ImageDecoder> decoderContainer;
     if (!resumeDecoding)
         decoderContainer = adoptPtr(decoder);
 
-    if (fullSizeImage.isNull()) {
+    if (image.isNull()) {
         // If decode has failed and resulted an empty image we can save work
         // in the future by returning early.
         m_decodeFailedAndEmpty = !m_isMultiFrame && decoder->failed();
 
         if (resumeDecoding)
             ImageDecodingStore::instance().unlockDecoder(this, decoder);
         return SkBitmap();
     }
 
     // If the image generated is complete then there is no need to keep
@@ skipping 15 matching lines @@
     if (resumeDecoding) {
         if (removeDecoder) {
             ImageDecodingStore::instance().removeDecoder(this, decoder);
             m_frameComplete.clear();
         } else {
             ImageDecodingStore::instance().unlockDecoder(this, decoder);
         }
     } else if (!removeDecoder) {
         ImageDecodingStore::instance().insertDecoder(this, decoderContainer.release());
     }
-    return fullSizeImage;
+    return image;
 }
 
 void ImageFrameGenerator::setHasAlpha(size_t index, bool hasAlpha)
 {
     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 outputType, const SkISize& outputSize, size_t rowBytes)
 {
     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);
 
+    if (outputSize.width() != m_fullSize.width() || outputSize.height() != m_fullSize.height()) {
+        ASSERT(allDataReceived);
+        ASSERT(!m_isMultiFrame);
+        if (m_isMultiFrame || !allDataReceived)
+            return false;
+    }
+
     // Try to create an ImageDecoder if we are not given one.
     if (!*decoder) {
-        newDecoder = true;
         if (m_imageDecoderFactory)
             *decoder = m_imageDecoderFactory->create().leakPtr();
 
         if (!*decoder)
             *decoder = ImageDecoder::create(*data, ImageDecoder::AlphaPremultiplied, ImageDecoder::GammaAndColorProfileApplied).leakPtr();
 
         if (!*decoder)
             return false;
     }
 
-    if (!m_isMultiFrame && newDecoder && allDataReceived) {
+    if (!m_isMultiFrame && allDataReceived) {
         // If we're using an external memory allocator that means we're decoding
         // directly into the output memory and we can save one memcpy.
         ASSERT(m_externalAllocator.get());
         (*decoder)->setMemoryAllocator(m_externalAllocator.get());
+        if (outputType != kN32_SkColorType || outputSize.width() != m_fullSize.width() || outputSize.height() != m_fullSize.height()) {
+            size_t maxDecodeBytes = outputSize.height() * rowBytes;
+            if (!(*decoder)->activateDecodeAndScale(static_cast<ImageFrame::ColorType>(outputType), maxDecodeBytes)) {
+                ASSERT(false);
+                (*decoder)->setMemoryAllocator(0);
+                return false;
+            }
+        }
     }
     (*decoder)->setData(data, allDataReceived);
+    ImageFrame* frame = (*decoder)->frameBufferAtIndex(index);
+    // restore back to default
+    (*decoder)->disableDecodeAndScale();
 
-    ImageFrame* frame = (*decoder)->frameBufferAtIndex(index);
     // For multi-frame image decoders, we need to know how many frames are
     // in that image in order to release the decoder when all frames are
     // decoded. frameCount() is reliable only if all data is received and set in
     // decoder, particularly with GIF.
     if (allDataReceived)
         m_frameCount = (*decoder)->frameCount();
 
     (*decoder)->setData(0, false); // Unref SharedBuffer from ImageDecoder.
     (*decoder)->clearCacheExceptFrame(index);
     (*decoder)->setMemoryAllocator(0);
 
     if (!frame || frame->status() == ImageFrame::FrameEmpty)
         return false;
 
     // A cache object is considered complete if we can decode a complete frame.
     // Or we have received all data. The image might not be fully decoded in
     // the latter case.
     const bool isDecodeComplete = frame->status() == ImageFrame::FrameComplete || allDataReceived;
-    SkBitmap fullSizeBitmap = frame->getSkBitmap();
-    if (!fullSizeBitmap.isNull())
+    SkBitmap decodedBitmap = frame->getSkBitmap();
+    if (!decodedBitmap.isNull())
     {
-        ASSERT(fullSizeBitmap.width() == m_fullSize.width() && fullSizeBitmap.height() == m_fullSize.height());
-        setHasAlpha(index, !fullSizeBitmap.isOpaque());
+        ASSERT(decodedBitmap.width() == outputSize.width() && decodedBitmap.height() == outputSize.height());
+        setHasAlpha(index, !decodedBitmap.isOpaque());
     }
-    *bitmap = fullSizeBitmap;
+    *bitmap = decodedBitmap;
     return isDecodeComplete;
 }
 
 bool ImageFrameGenerator::hasAlpha(size_t index)
 {
     MutexLocker lock(m_alphaMutex);
     if (index < m_hasAlpha.size())
         return m_hasAlpha[index];
     return true;
 }
@@ skipping 22 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);
 }
 
+void ImageFrameGenerator::getAvailableDecodeAndScale(SkColorType* outType, float* scale, float* lowerScale)
+{
+    // as the same buffer could be used to store consecutive frames, avoid the complexity
+    // since some of consecutive frames could have alpha
+    if (m_isMultiFrame) {
+        // pass the same content as in default ImageDecoder
+        ImageDecoder::defaultDecodeAndScale(reinterpret_cast<ImageFrame::ColorType*>(outType), scale, lowerScale);
+    }
+
+    // FIXME check how much this cost (decoder creation) and, also for getYUVComponentSizes,
+    // cache it in ImageDecodingStore for the real decode
+    SharedBuffer* data = 0;
+    bool allDataReceived = false;
+    m_data.data(&data, &allDataReceived);
+
+    // partially received data needs to have alpha and skip downsampling
+    if (allDataReceived) {
+        OwnPtr<ImageDecoder> decoder = ImageDecoder::create(*data, ImageDecoder::AlphaPremultiplied, ImageDecoder::GammaAndColorProfileApplied);
+        if (decoder) {
+            decoder->getAvailableDecodeAndScale(reinterpret_cast<ImageFrame::ColorType*>(outType), scale, lowerScale);
+            return;
+        }
+    }
+    ImageDecoder::defaultDecodeAndScale(reinterpret_cast<ImageFrame::ColorType*>(outType), scale, lowerScale);
+}
+
 } // namespace blink