Allowing YUV data to be retrieved from the JPEG Decoder.

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 115 matching lines @@
     // 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.fWidth, info.fHeight);
     ASSERT(m_fullSize == scaledSize);
 
     if (m_decodeFailedAndEmpty)
-        return 0;
+        return false;
 
     TRACE_EVENT2("blink", "ImageFrameGenerator::decodeAndScale", "generator", this, "decodeCount", static_cast<int>(m_decodeCount));
 
     // Don't use discardable memory for decoding if Skia is providing output
     // memory. Instead use ExternalMemoryAllocator such that we can
     // write directly to the memory given by Skia.
     //
     // TODO:
     // This is not pretty because this class is used in two different code
     // paths: discardable memory decoding on Android and discardable memory
@@ skipping 15 matching lines @@
 
     bool result = true;
     // Check to see if decoder has written directly to the memory provided
     // by Skia. If not make a copy.
     if (cachedImage->bitmap().getPixels() != pixels)
         result = cachedImage->bitmap().copyPixelsTo(pixels, rowBytes * info.fHeight, rowBytes);
     ImageDecodingStore::instance()->unlockCache(this, cachedImage);
     return result;
 }
 
+bool ImageFrameGenerator::decodeAndScale(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);
+
+    if (m_decodeFailedAndEmpty)
+        return false;
+
+    TRACE_EVENT2("blink", "ImageFrameGenerator::decodeAndScale", "generator", this, "decodeCount", static_cast<int>(m_decodeCount));
+
+    m_hardwareDecoding = (0 != planes) && (0 != planes[0]) && (0 != planes[1]) && (0 != planes[2]) && (0 != rowBytes) && (0 != rowBytes[0]) && (0 != rowBytes[1]) && (0 != rowBytes[2]);
+    if (!m_hardwareDecoding) {
+        return false;
+    }
+
+    DecodingBuffers* decodingBuffers = new DecodingBuffers;
+    decodingBuffers->set(planes, rowBytes);
+    m_decodingBuffers = adoptPtr(decodingBuffers);
+
+    ImageDecoder* decoder = 0;
+    const bool isCached = ImageDecodingStore::instance()->lockDecoder(this, m_fullSize, &decoder);
+    ASSERT(!isCached || decoder);
+
+    decode(0, &decoder);
+
+    if (isCached) {
+        ImageDecodingStore::instance()->unlockDecoder(this, decoder);
+    }
+
+    return m_hardwareDecoding;

[Stephen White, 2014/07/23 21:45:53]

Naming nit: generally we use "accelerated" (or sometimes "GPU") in Blink, rather
than "hardware" (CPU is hardware too). Suggest m_acceleratedDecoding.

In fact, since we aren't accelerating the whole JPG stack, maybe this should be
m_acceleratedYUVDecoding?

[sugoi1, 2014/07/24 15:48:29]

Done.

+}
+
 const ScaledImageFragment* ImageFrameGenerator::tryToLockCompleteCache(const SkISize& scaledSize, size_t index)
 {
     const ScaledImageFragment* cachedImage = 0;
     if (ImageDecodingStore::instance()->lockCache(this, scaledSize, index, &cachedImage))
         return cachedImage;
     return 0;
 }
 
 const ScaledImageFragment* ImageFrameGenerator::tryToResumeDecode(const SkISize& scaledSize, size_t index)
 {
@@ skipping 73 matching lines @@
     if (!m_isMultiFrame && newDecoder && 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.
         canSkipBitmapCopy = true;
         if (m_externalAllocator)
             (*decoder)->setMemoryAllocator(m_externalAllocator.get());
         else
             (*decoder)->setMemoryAllocator(m_discardableAllocator.get());
     }
     (*decoder)->setData(data, allDataReceived);
+    if (m_hardwareDecoding) {
+        (*decoder)->setDecodingBuffers(m_decodingBuffers);
+        m_hardwareDecoding = (*decoder)->doHardwareDecoding();
+        return nullptr;
+    }
     // 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(index);
     (*decoder)->setData(0, false); // Unref SharedBuffer from ImageDecoder.
     (*decoder)->clearCacheExceptFrame(index);
     (*decoder)->setMemoryAllocator(0);
 
@@ skipping 42 matching lines @@
 }
 
 bool ImageFrameGenerator::hasAlpha(size_t index)
 {
     MutexLocker lock(m_alphaMutex);
     if (index < m_hasAlpha.size())
         return m_hasAlpha[index];
     return true;
 }
 
+bool ImageFrameGenerator::getComponentSizes(SkISize* componentSizes)
+{
+    if (!componentSizes) {
+        return false;
+    }
+
+    TRACE_EVENT2("webkit", "ImageFrameGenerator::getImageFormat", "width", m_fullSize.width(), "height", m_fullSize.height());
+
+    ImageDecoder* decoder = 0;
+    const bool isCached = ImageDecodingStore::instance()->lockDecoder(this, m_fullSize, &decoder);
+    ASSERT(!isCached || decoder);
+
+    SharedBuffer* data = 0;
+    bool allDataReceived = false;
+    m_data.data(&data, &allDataReceived);
+
+    // Try to create an ImageDecoder

[Peter Kasting, 2014/07/23 22:17:36]

Nit: This comment adds little to the code.

[sugoi1, 2014/07/24 15:48:29]

Done.

+    if (!decoder && m_imageDecoderFactory) {

[Peter Kasting, 2014/07/23 22:17:37]

Nit: No {} (several places)

[sugoi1, 2014/07/24 15:48:29]

Done.

+        decoder = m_imageDecoderFactory->create().leakPtr();
+    }
+
+    if (!decoder) {
+        decoder = ImageDecoder::create(*data, ImageSource::AlphaPremultiplied, ImageSource::GammaAndColorProfileApplied).leakPtr();
+    }
+
+    if (!decoder) {

[Peter Kasting, 2014/07/23 22:17:36]

Nit: This can be moved inside the conditional above

[sugoi1, 2014/07/24 15:48:29]

Done.

+        return false;
+    }
+
+    // If the decoder isn't cached, take ownership of it here

[Peter Kasting, 2014/07/23 22:17:36]

Nit: Another poor-quality comment.

[sugoi1, 2014/07/24 15:48:29]

Done.

[Peter Kasting, 2014/07/24 18:08:13]

Actually you don't seem to have removed or improved the comment.

+    OwnPtr<ImageDecoder> decoderContainer;

[Peter Kasting, 2014/07/23 22:17:36]

Nit: Instead of declaring this down here, why not declare it much higher up, and
take ownership directly in the places you currently call leakPtr()?  That seems
clearer and safer.

[sugoi1, 2014/07/24 15:48:29]

Done.

+    if (!isCached) {
+        decoderContainer = adoptPtr(decoder);
+    }
+
+    decoder->setData(data, allDataReceived);
+    decoder->setHardwareDecoding(true);
+    bool canComputeSize = decoder->hardwareDecoding() && decoder->isSizeAvailable();
+    if (canComputeSize) {
+        IntSize size = decoder->decodedSize(0);
+        componentSizes[0].set(size.width(), size.height());
+        size = decoder->decodedSize(1);
+        componentSizes[1].set(size.width(), size.height());
+        size = decoder->decodedSize(2);
+        componentSizes[2].set(size.width(), size.height());
+    }
+    decoder->setData(0, false); // Unref SharedBuffer from ImageDecoder.
+    if (isCached) {
+        ImageDecodingStore::instance()->unlockDecoder(this, decoder);
+    }
+    return canComputeSize;
+}
+
 } // namespace