ImageBuffer-less SVG masking and clipping.

Source/core/platform/graphics/ImageBuffer.cpp

 /*
  * Copyright (c) 2008, Google Inc. All rights reserved.
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
@@ skipping 32 matching lines @@
 #include "core/platform/graphics/chromium/Canvas2DLayerBridge.h"
 #include "core/platform/graphics/gpu/SharedGraphicsContext3D.h"
 #include "core/platform/graphics/skia/NativeImageSkia.h"
 #include "core/platform/graphics/skia/SkiaUtils.h"
 #include "core/platform/image-encoders/skia/JPEGImageEncoder.h"
 #include "core/platform/image-encoders/skia/PNGImageEncoder.h"
 #include "core/platform/image-encoders/skia/WEBPImageEncoder.h"
 #include "public/platform/Platform.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkBitmapDevice.h"
+#include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 #include "third_party/skia/include/core/SkSurface.h"
+#include "third_party/skia/include/effects/SkTableColorFilter.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/SkGpuDevice.h"
 #include "wtf/MathExtras.h"
 #include "wtf/text/Base64.h"
 #include "wtf/text/WTFString.h"
 
 using namespace std;
 
 namespace WebCore {
 
@@ skipping 193 matching lines @@
     const FloatPoint& phase, CompositeOperator op, const FloatRect& destRect, BlendMode blendMode)
 {
     if (!isValid())
         return;
 
     const SkBitmap& bitmap = *m_context->bitmap();
     RefPtr<Image> image = BitmapImage::create(NativeImageSkia::create(drawNeedsCopy(m_context.get(), context) ? deepSkBitmapCopy(bitmap) : bitmap));
     image->drawPattern(context, srcRect, scale, phase, op, destRect, blendMode);
 }
 
+static const Vector<uint8_t>& getLinearRgbLUT()
+{
+    DEFINE_STATIC_LOCAL(Vector<uint8_t>, linearRgbLUT, ());

[pdr., 2013/08/28 03:32:36]

Since you know the final size already, can you initialize this Vector with the
correct size?

[f(malita), 2013/08/28 19:54:38]

Good idea.

Simply passing a constructor size argument doesn't work well though, as the
vector ends up initializing $size elements upfront. Not only does this mess up
the initialization detection logic, but it also causes an unnecessary iteration.

I believe what we want to use is the template inlineCapacity arg
(Vector<typename T, size_t inlineCapacity = 0>), but unfortunately that doesn't
seem to be usable for statically defined vectors.

So the next best thing is an explicit reserveCapacity(256) call before entering
the initialization loop - to avoid growing the capacity in smaller increments
(not sure that was ever the case but doesn't hurt to be explicit). So let's do
this.

+    if (linearRgbLUT.isEmpty()) {
+        for (unsigned i = 0; i < 256; i++) {
+            float color = i  / 255.0f;
+            color = (color <= 0.04045f ? color / 12.92f : pow((color + 0.055f) / 1.055f, 2.4f));
+            color = std::max(0.0f, color);
+            color = std::min(1.0f, color);
+            linearRgbLUT.append(static_cast<uint8_t>(round(color * 255)));
+        }
+    }
+    return linearRgbLUT;
+}
+
+static const Vector<uint8_t>& getDeviceRgbLUT()
+{
+    DEFINE_STATIC_LOCAL(Vector<uint8_t>, deviceRgbLUT, ());
+    if (deviceRgbLUT.isEmpty()) {
+        for (unsigned i = 0; i < 256; i++) {
+            float color = i / 255.0f;
+            color = (powf(color, 1.0f / 2.4f) * 1.055f) - 0.055f;
+            color = std::max(0.0f, color);
+            color = std::min(1.0f, color);
+            deviceRgbLUT.append(static_cast<uint8_t>(round(color * 255)));
+        }
+    }
+    return deviceRgbLUT;
+}
+
 void ImageBuffer::transformColorSpace(ColorSpace srcColorSpace, ColorSpace dstColorSpace)
 {
     if (srcColorSpace == dstColorSpace)
         return;
 
     // only sRGB <-> linearRGB are supported at the moment
     if ((srcColorSpace != ColorSpaceLinearRGB && srcColorSpace != ColorSpaceDeviceRGB)
         || (dstColorSpace != ColorSpaceLinearRGB && dstColorSpace != ColorSpaceDeviceRGB))
         return;
 
@@ skipping 16 matching lines @@
             SkColor color = SkPMColorToColor(srcRow[x]);
             srcRow[x] = SkPreMultiplyARGB(
                 SkColorGetA(color),
                 lookUpTable[SkColorGetR(color)],
                 lookUpTable[SkColorGetG(color)],
                 lookUpTable[SkColorGetB(color)]);
         }
     }
 }
 
-const Vector<uint8_t>& ImageBuffer::getLinearRgbLUT()
+PassRefPtr<SkColorFilter> ImageBuffer::createColorSpaceFilter(ColorSpace srcColorSpace,

[Stephen White, 2013/08/28 14:11:10]

Maybe at some point we can use this in place of
ImageBuffer::transformColorSpace() (or at least, use it in its implementation).

[f(malita), 2013/08/28 19:54:38]

Makes sense. The only transformColorSpace() user left appears to be
FilterEffect::transformResultColorSpace() so maybe it will just die off when
you're done Skia-fying the filter chain.

+    ColorSpace dstColorSpace)
 {
-    DEFINE_STATIC_LOCAL(Vector<uint8_t>, linearRgbLUT, ());
-    if (linearRgbLUT.isEmpty()) {
-        for (unsigned i = 0; i < 256; i++) {
-            float color = i  / 255.0f;
-            color = (color <= 0.04045f ? color / 12.92f : pow((color + 0.055f) / 1.055f, 2.4f));
-            color = std::max(0.0f, color);
-            color = std::min(1.0f, color);
-            linearRgbLUT.append(static_cast<uint8_t>(round(color * 255)));
-        }
-    }
-    return linearRgbLUT;
+    if ((srcColorSpace == dstColorSpace)
+        || (srcColorSpace != ColorSpaceLinearRGB && srcColorSpace != ColorSpaceDeviceRGB)
+        || (dstColorSpace != ColorSpaceLinearRGB && dstColorSpace != ColorSpaceDeviceRGB))
+        return 0;
+
+    const uint8_t* lut = 0;
+    if (dstColorSpace == ColorSpaceLinearRGB)
+        lut = &getLinearRgbLUT()[0];
+    else if (dstColorSpace == ColorSpaceDeviceRGB)
+        lut = &getDeviceRgbLUT()[0];
+    else
+        return 0;
+
+    return adoptRef(SkTableColorFilter::CreateARGB(0, lut, lut, lut));
 }
 
-const Vector<uint8_t>& ImageBuffer::getDeviceRgbLUT()
-{
-    DEFINE_STATIC_LOCAL(Vector<uint8_t>, deviceRgbLUT, ());
-    if (deviceRgbLUT.isEmpty()) {
-        for (unsigned i = 0; i < 256; i++) {
-            float color = i / 255.0f;
-            color = (powf(color, 1.0f / 2.4f) * 1.055f) - 0.055f;
-            color = std::max(0.0f, color);
-            color = std::min(1.0f, color);
-            deviceRgbLUT.append(static_cast<uint8_t>(round(color * 255)));
-        }
-    }
-    return deviceRgbLUT;
-}
-
-
 template <Multiply multiplied>
 PassRefPtr<Uint8ClampedArray> getImageData(const IntRect& rect, GraphicsContext* context, const IntSize& size)
 {
     float area = 4.0f * rect.width() * rect.height();
     if (area > static_cast<float>(std::numeric_limits<int>::max()))
         return 0;
 
     RefPtr<Uint8ClampedArray> result = Uint8ClampedArray::createUninitialized(rect.width() * rect.height() * 4);
 
     unsigned char* data = result->data();
@@ skipping 71 matching lines @@
 
     SkCanvas::Config8888 config8888;
     if (multiplied == Premultiplied)
         config8888 = SkCanvas::kRGBA_Premul_Config8888;
     else
         config8888 = SkCanvas::kRGBA_Unpremul_Config8888;
 
     context()->writePixels(srcBitmap, destX, destY, config8888);
 }
 
-void ImageBuffer::convertToLuminanceMask()
-{
-    IntRect luminanceRect(IntPoint(), internalSize());
-    RefPtr<Uint8ClampedArray> srcPixelArray = getUnmultipliedImageData(luminanceRect);
-
-    unsigned pixelArrayLength = srcPixelArray->length();
-    for (unsigned pixelOffset = 0; pixelOffset < pixelArrayLength; pixelOffset += 4) {
-        unsigned char a = srcPixelArray->item(pixelOffset + 3);
-        if (!a)
-            continue;
-        unsigned char r = srcPixelArray->item(pixelOffset);
-        unsigned char g = srcPixelArray->item(pixelOffset + 1);
-        unsigned char b = srcPixelArray->item(pixelOffset + 2);
-
-        double luma = (r * 0.2125 + g * 0.7154 + b * 0.0721) * ((double)a / 255.0);
-        srcPixelArray->set(pixelOffset + 3, luma);
-    }
-    putByteArray(Unmultiplied, srcPixelArray.get(), luminanceRect.size(), luminanceRect, IntPoint());
-}
-
 template <typename T>
 static bool encodeImage(T& source, const String& mimeType, const double* quality, Vector<char>* output)
 {
     Vector<unsigned char>* encodedImage = reinterpret_cast<Vector<unsigned char>*>(output);
 
     if (mimeType == "image/jpeg") {
         int compressionQuality = JPEGImageEncoder::DefaultCompressionQuality;
         if (quality && *quality >= 0.0 && *quality <= 1.0)
             compressionQuality = static_cast<int>(*quality * 100 + 0.5);
         if (!JPEGImageEncoder::encode(source, compressionQuality, encodedImage))
@@ skipping 34 matching lines @@
     if (!encodeImage(imageData, mimeType, quality, &encodedImage))
         return "data:,";
 
     Vector<char> base64Data;
     base64Encode(encodedImage, base64Data);
 
     return "data:" + mimeType + ";base64," + base64Data;
 }
 
 } // namespace WebCore