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 57 matching lines @@
 private:
     SkImageInfo m_info;
     void* m_pixels;
     size_t m_rowBytes;
 };
 
 ImageFrameGenerator::ImageFrameGenerator(const SkISize& fullSize, PassRefPtr<SharedBuffer> data, bool allDataReceived, bool isMultiFrame)
     : m_fullSize(fullSize)
     , m_isMultiFrame(isMultiFrame)
     , m_decodeFailedAndEmpty(false)
+    , m_acceleratedYUVDecoding(false)
     , m_decodeCount(ScaledImageFragment::FirstPartialImage)
     , m_discardableAllocator(adoptPtr(new DiscardablePixelRefAllocator()))
 {
     setData(data.get(), allDataReceived);
 }
 
 ImageFrameGenerator::~ImageFrameGenerator()
 {
     ImageDecodingStore::instance()->removeCacheIndexedByGenerator(this);
 }
@@ skipping 38 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_acceleratedYUVDecoding = (0 != planes) && (0 != planes[0]) && (0 != planes[1]) && (0 != planes[2]) && (0 != rowBytes) && (0 != rowBytes[0]) && (0 != rowBytes[1]) && (0 != rowBytes[2]);
+    if (!m_acceleratedYUVDecoding) {
+        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_acceleratedYUVDecoding;
+}
+
 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_acceleratedYUVDecoding) {
+        (*decoder)->setDecodingBuffers(m_decodingBuffers);
+        m_acceleratedYUVDecoding = (*decoder)->doAcceleratedYUVDecoding();
+        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[3])
+{
+    if (!componentSizes) {
+        return false;
+    }
+
+    TRACE_EVENT2("webkit", "ImageFrameGenerator::getImageFormat", "width", m_fullSize.width(), "height", m_fullSize.height());
+
+    ImageDecoder* decoder = 0;

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

Nit: Seems like this block should move down below the SharedBuffer block to be
with the rest of the code that mucks with |decoder|.

+    const bool isCached = ImageDecodingStore::instance()->lockDecoder(this, m_fullSize, &decoder);
+    ASSERT(!isCached || decoder);
+
+    SharedBuffer* data = 0;
+    bool allDataReceived = false;
+    m_data.data(&data, &allDataReceived);
+
+    // If the decoder isn't cached, take ownership of it here
+    OwnPtr<ImageDecoder> decoderContainer;
+    if (!isCached)
+        decoderContainer = adoptPtr(decoder);
+
+    if (!decoder) {
+        if (m_imageDecoderFactory)
+            decoderContainer = adoptPtr(m_imageDecoderFactory->create().leakPtr());

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

Do we actually have to call leakPtr() explicitly here and below?  (I don't use
the Blink smart pointer types enough to know.)

+
+        if (!decoderContainer.get())
+            decoderContainer = adoptPtr(ImageDecoder::create(*data, ImageSource::AlphaPremultiplied, ImageSource::GammaAndColorProfileApplied).leakPtr());
+
+        decoder = decoderContainer.get();
+
+        if (!decoder)
+            return false;
+    }
+
+    decoder->setData(data, allDataReceived);
+    decoder->setAcceleratedYUVDecoding(true);
+    bool canComputeSize = decoder->acceleratedYUVDecoding() && 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