Changeset 83949 in webkit

Timestamp:

Apr 14, 2011 10:43:27 PM (13 years ago)

Author:

commit-queue@webkit.org

Message:

2011-04-14 Justin Novosad <​junov@chromium.org>

Reviewed by Kenneth Russell.

[Chromium] Accelerated 2D Canvas is slow to execute putImageData
​https://bugs.webkit.org/show_bug.cgi?id=57960

• platform/chromium/test_expectations.txt: added expected failure for test canvas/philip/tests/2d.gradient.interpolate.colouralpha.html Logged as chromium issue: ​http://code.google.com/p/chromium/issues/detail?id=79477

2011-04-14 Justin Novosad <​junov@chromium.org>

Reviewed by Kenneth Russell.

[Chromium] Accelerated 2D Canvas is slow to execute putImageData
​https://bugs.webkit.org/show_bug.cgi?id=57960

• platform/graphics/chromium/GLES2Canvas.cpp: (WebCore::GLES2Canvas::drawTexturedRect): Added an option for using the blend ops for alpha multiplication instead of compositing. (WebCore::GLES2Canvas::applyClipping): (WebCore::GLES2Canvas::putImageData): New method for drawing raw pixel data from memory to the canvas (WebCore::GLES2Canvas::putUnmultipliedImageData): Wrapper for putImageData (WebCore::GLES2Canvas::putPremultipliedImageData): Wrapper for putImageData
• platform/graphics/chromium/GLES2Canvas.h:
• platform/graphics/gpu/Texture.cpp: (WebCore::copySubRect): (WebCore::Texture::load): (WebCore::Texture::updateSubRect): Added an overload of the updateSubRect method that can receive a pixel of a size that is different from texture size. Improved the performance of updateSubrect by avoiding the allocation of a temporary buffer when not required.
• platform/graphics/gpu/Texture.h:
• platform/graphics/skia/ImageBufferSkia.cpp: (WebCore::getImageData): In the unmultiplied path, division by alpha now performs proper rounding in order to avoid generational degradation with putImageData (WebCore::putImageData): Alpha multiplication now performs proper rounding in order to be consistent with the hardware rendering path: OpenGL always rounds when converting to fixed point representation. (WebCore::ImageBuffer::putUnmultipliedImageData): Now supports a hardware rendering path, which eliminates the need for a readback from the GPU (WebCore::ImageBuffer::putPremultipliedImageData): Now supports a hardware rendering path, which eliminates the need for a readback from the GPU

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/platform/chromium/test_expectations.txt (modified) (1 diff)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/platform/graphics/chromium/GLES2Canvas.cpp (modified) (4 diffs)
• Source/WebCore/platform/graphics/chromium/GLES2Canvas.h (modified) (3 diffs)
• Source/WebCore/platform/graphics/gpu/Texture.cpp (modified) (4 diffs)
• Source/WebCore/platform/graphics/gpu/Texture.h (modified) (2 diffs)
• Source/WebCore/platform/graphics/skia/ImageBufferSkia.cpp (modified) (3 diffs)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2011-04-14  Justin Novosad  <junov@chromium.org>
+
+        Reviewed by Kenneth Russell.
+
+        [Chromium] Accelerated 2D Canvas is slow to execute putImageData
+        https://bugs.webkit.org/show_bug.cgi?id=57960
+
+        * platform/chromium/test_expectations.txt:
+        added expected failure for test
+        canvas/philip/tests/2d.gradient.interpolate.colouralpha.html
+        Logged as chromium issue:
+        http://code.google.com/p/chromium/issues/detail?id=79477
+
 2011-04-14  Adrienne Walker  <enne@google.com>
 

trunk/LayoutTests/platform/chromium/test_expectations.txt

@@ -699 +699 @@
 // selection
 BUGCR10369 LINUX : editing/selection/5354455-2.html = FAIL
+
+BUGCR79477 LINUX WIN : canvas/philip/tests/2d.gradient.interpolate.colouralpha.html = TEXT
 
 // TODO(erg): Attempted to rebaseline these tests as part of the above

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2011-04-14  Justin Novosad  <junov@chromium.org>
+
+        Reviewed by Kenneth Russell.
+
+        [Chromium] Accelerated 2D Canvas is slow to execute putImageData
+        https://bugs.webkit.org/show_bug.cgi?id=57960
+
+        * platform/graphics/chromium/GLES2Canvas.cpp:
+        (WebCore::GLES2Canvas::drawTexturedRect):
+        Added an option for using the blend ops for alpha multiplication
+        instead of compositing.
+        (WebCore::GLES2Canvas::applyClipping):
+        (WebCore::GLES2Canvas::putImageData):
+        New method for drawing raw pixel data from memory to the canvas
+        (WebCore::GLES2Canvas::putUnmultipliedImageData):
+        Wrapper for putImageData
+        (WebCore::GLES2Canvas::putPremultipliedImageData):
+        Wrapper for putImageData
+        * platform/graphics/chromium/GLES2Canvas.h:
+        * platform/graphics/gpu/Texture.cpp:
+        (WebCore::copySubRect):
+        (WebCore::Texture::load):
+        (WebCore::Texture::updateSubRect):
+        Added an overload of the updateSubRect method that can receive a pixel 
+        of a size that is different from texture size. Improved the performance
+        of updateSubrect by avoiding the allocation of a temporary buffer when
+        not required.
+        * platform/graphics/gpu/Texture.h:
+        * platform/graphics/skia/ImageBufferSkia.cpp:
+        (WebCore::getImageData):
+        In the unmultiplied path, division by alpha now performs proper
+        rounding in order to avoid generational degradation with putImageData
+        (WebCore::putImageData):
+        Alpha multiplication now performs proper rounding in order to be
+        consistent with the hardware rendering path: OpenGL always rounds when
+        converting to fixed point representation.
+        (WebCore::ImageBuffer::putUnmultipliedImageData):
+        Now supports a hardware rendering path, which eliminates the need
+        for a readback from the GPU
+        (WebCore::ImageBuffer::putPremultipliedImageData):
+        Now supports a hardware rendering path, which eliminates the need
+        for a readback from the GPU
+
 2011-04-14  Joone Hur  <joone.hur@collabora.co.uk>
 

trunk/Source/WebCore/platform/graphics/chromium/GLES2Canvas.cpp

@@ -33 +33 @@
 #include "GLES2Canvas.h"
 
+#include "ByteArray.h"
 #include "DrawingBuffer.h"
 #include "FloatRect.h"
@@ -58 +59 @@
 namespace WebCore {
 
+using WTF::ByteArray;
+
 // Number of line segments used to approximate bezier curves.
 const int pathTesselation = 30;
@@ -407 +410 @@
 void GLES2Canvas::drawTexturedRect(Texture* texture, const FloatRect& srcRect, const FloatRect& dstRect, ColorSpace colorSpace, CompositeOperator compositeOp)
 {
-    drawTexturedRect(texture, srcRect, dstRect, m_state->m_ctm, m_state->m_alpha, colorSpace, compositeOp, m_state->clippingEnabled());
-}
-
-
-void GLES2Canvas::drawTexturedRect(Texture* texture, const FloatRect& srcRect, const FloatRect& dstRect, const AffineTransform& transform, float alpha, ColorSpace colorSpace, CompositeOperator compositeOp, bool clip)
+    drawTexturedRect(texture, srcRect, dstRect, m_state->m_ctm, m_state->m_alpha, colorSpace, compositeOp, m_state->clippingEnabled() ? ApplyClipping : 0);
+}
+
+void GLES2Canvas::drawTexturedRect(Texture* texture, const FloatRect& srcRect, const FloatRect& dstRect, const AffineTransform& transform, float alpha, ColorSpace colorSpace, CompositeOperator compositeOp, unsigned drawTextureFlags)
 {
     bindFramebuffer();
-    m_context->applyCompositeOperator(compositeOp);
-    applyClipping(clip);
+    
+    if (drawTextureFlags & MultiplySourceAlpha) {
+        // The multiply option hijacks the blend func, so it can't be combined with a compositing op
+        ASSERT(CompositeCopy == compositeOp);
+        // Custom composite operation that performs alpha multiplication on color components
+        m_context->graphicsContext3D()->enable(GraphicsContext3D::BLEND);
+        m_context->graphicsContext3D()->blendFuncSeparate(GraphicsContext3D::SRC_ALPHA, GraphicsContext3D::ZERO, GraphicsContext3D::ONE, GraphicsContext3D::ZERO);
+    } else
+        m_context->applyCompositeOperator(compositeOp);
+    applyClipping(drawTextureFlags & ApplyClipping);
     const TilingData& tiles = texture->tiles();
     IntRect tileIdxRect = tiles.overlappedTileIndices(srcRect);
@@ -904 +914 @@
 }
 
+void GLES2Canvas::putImageData(void* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint, Texture::Format format, float alpha, ColorSpace colorSpace, CompositeOperator op, unsigned drawTextureFlags)
+{
+    ASSERT(source);
+    IntRect clippedSourceRect(0, 0, sourceSize.width(), sourceSize.height());
+    clippedSourceRect.intersect(sourceRect);
+    int deltaX = clippedSourceRect.x() - sourceRect.x();
+    int deltaY = clippedSourceRect.y() - sourceRect.y();
+    IntPoint adjustedDestPoint(destPoint.x() + deltaX, destPoint.y() + deltaY);    
+    IntRect destRect(adjustedDestPoint, clippedSourceRect.size());
+    IntRect canvasRect(0, 0, m_size.width(), m_size.height());
+    destRect.intersect(canvasRect);
+    deltaX = destRect.x() - adjustedDestPoint.x();
+    deltaY = destRect.y() - adjustedDestPoint.y();
+    clippedSourceRect.move(deltaX, deltaY);
+    clippedSourceRect.setSize(destRect.size());
+    if (!clippedSourceRect.width() || !clippedSourceRect.height()) 
+        return;
+    RefPtr<Texture> uploadTexture = m_context->createTexture(format, clippedSourceRect.width(), clippedSourceRect.height());
+    IntRect texUpdateRect(0, 0, clippedSourceRect.width(), clippedSourceRect.height());
+    // To get the row stride right, we still take the width of the full buffer for the source size.
+    IntSize adjustedSourceSize(sourceSize.width(), texUpdateRect.height());
+    uploadTexture->updateSubRect(((char*)source) + (clippedSourceRect.y() * sourceSize.width() + clippedSourceRect.x()) * 4, adjustedSourceSize, texUpdateRect);
+    AffineTransform identity;
+    drawTexturedRect(uploadTexture.get(), texUpdateRect, destRect, identity, alpha, colorSpace, op, drawTextureFlags);
+}
+
+void GLES2Canvas::putUnmultipliedImageData(ByteArray* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint)
+{
+    IntPoint newDestPoint(destPoint.x() + sourceRect.x(), destPoint.y() + sourceRect.y());
+    putImageData(source->data(), sourceSize, sourceRect, newDestPoint, Texture::RGBA8, 1.0f, ColorSpaceDeviceRGB, CompositeCopy, MultiplySourceAlpha);
+}
+
+void GLES2Canvas::putPremultipliedImageData(ByteArray* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint)
+{
+    IntPoint newDestPoint(destPoint.x() + sourceRect.x(), destPoint.y() + sourceRect.y());
+    putImageData(source->data(), sourceSize, sourceRect, newDestPoint, Texture::RGBA8, 1.0f, ColorSpaceDeviceRGB, CompositeCopy, 0);
+}
+
 void GLES2Canvas::checkGLError(const char* header)
 {

trunk/Source/WebCore/platform/graphics/chromium/GLES2Canvas.h

@@ -44 +44 @@
 #include <wtf/Vector.h>
 
+namespace WTF {
+class ByteArray;
+}
+
 namespace WebCore {
 
@@ -56 +60 @@
     WTF_MAKE_NONCOPYABLE(GLES2Canvas);
 public:
+    enum DrawTextureFlags {
+        ApplyClipping =         1 << 0,
+        MultiplySourceAlpha =   1 << 1
+    };
+
     GLES2Canvas(SharedGraphicsContext3D*, DrawingBuffer*, const IntSize&);
     ~GLES2Canvas();
@@ -89 +98 @@
     // This version is called by BitmapImage::draw().
     void drawTexturedRect(Texture*, const FloatRect& srcRect, const FloatRect& dstRect, ColorSpace, CompositeOperator);
-    // This version is called by the above, and by the software->hardware uploads.
-    void drawTexturedRect(Texture*, const FloatRect& srcRect, const FloatRect& dstRect, const AffineTransform&, float alpha, ColorSpace, CompositeOperator, bool clip);
+    // This version is called by the above, by putImageData, and by the software->hardware uploads.
+    void drawTexturedRect(Texture*, const FloatRect& srcRect, const FloatRect& dstRect, const AffineTransform&, float alpha, ColorSpace, CompositeOperator, unsigned drawTextureFlags);
     Texture* createTexture(NativeImagePtr, Texture::Format, int width, int height);
     Texture* getTexture(NativeImagePtr);
+    void putImageData(void* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint, Texture::Format, float alpha, ColorSpace, CompositeOperator, unsigned drawTextureFlags);
+    void putUnmultipliedImageData(WTF::ByteArray* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint);
+    void putPremultipliedImageData(WTF::ByteArray* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint);
 
     SharedGraphicsContext3D* context() const { return m_context; }

trunk/Source/WebCore/platform/graphics/gpu/Texture.cpp

@@ -121 +121 @@
 
 template <bool swizzle>
-static uint32_t* copySubRect(uint32_t* src, int srcX, int srcY, uint32_t* dst, int width, int height, int srcStride)
+static void copySubRect(uint32_t* src, int srcX, int srcY, uint32_t* dst, int width, int height, int srcStride)
 {
     uint32_t* srcOffset = src + srcX + srcY * srcStride;
-
-    if (!swizzle && width == srcStride)
-        return srcOffset;
-
     if (swizzle) {
         uint32_t* dstPixel = dst;
@@ -142 +138 @@
         }
     }
-    return dst;
 }
 
 void Texture::load(void* pixels)
 {
-    updateSubRect(pixels, IntRect(0, 0, m_tiles.totalSizeX(), m_tiles.totalSizeY()));
+    updateSubRect(pixels, IntSize(m_tiles.totalSizeX(), m_tiles.totalSizeY()), IntRect(0, 0, m_tiles.totalSizeX(), m_tiles.totalSizeY()));
 }
 
 void Texture::updateSubRect(void* pixels, const IntRect& updateRect)
 {
+    updateSubRect(pixels, IntSize(m_tiles.totalSizeX(), m_tiles.totalSizeY()), updateRect);
+}
+
+void Texture::updateSubRect(void* pixels, const IntSize& pixelBufferSize, const IntRect& updateRect)
+{
+    IntSize updateBounds = pixelBufferSize.shrunkTo(IntSize(m_tiles.totalSizeX(), m_tiles.totalSizeY()));
     IntRect updateRectSanitized(updateRect);
-    updateRectSanitized.intersect(IntRect(0, 0, m_tiles.totalSizeX(), m_tiles.totalSizeY()));
+    updateRectSanitized.intersect(IntRect(0, 0, updateBounds.width(), updateBounds.height()));
 
     uint32_t* pixels32 = static_cast<uint32_t*>(pixels);
@@ -164 +165 @@
         // FIXME:  This could use PBO's to save doing an extra copy here.
     }
+
     int tempBuffSize = // Temporary buffer size is the smaller of the max texture size or the updateRectSanitized
         min(m_tiles.maxTextureSize(), m_tiles.borderTexels() + updateRectSanitized.width()) *
         min(m_tiles.maxTextureSize(), m_tiles.borderTexels() + updateRectSanitized.height());
-    OwnArrayPtr<uint32_t> tempBuff = adoptArrayPtr(new uint32_t[tempBuffSize]);
+    bool needTempBuff = swizzle || updateRect.width() != m_tiles.totalSizeX() || updateRect.width() != pixelBufferSize.width() || m_tiles.numTilesX() > 1;
+    OwnArrayPtr<uint32_t> tempBuff;
+    if (needTempBuff)
+        tempBuff = adoptArrayPtr(new uint32_t[tempBuffSize]);
 
     for (int tile = 0; tile < m_tiles.numTiles(); tile++) {
@@ -182 +187 @@
             continue;
 
-        // Copy sub rectangle out of larger pixel data
         uint32_t* uploadBuff = 0;
-        if (swizzle) {
-            uploadBuff = copySubRect<true>(
-            pixels32, updateRectIntersected.x(), updateRectIntersected.y(),
-            tempBuff.get(), updateRectIntersected.width(), updateRectIntersected.height(), m_tiles.totalSizeX());
+        if (needTempBuff) {
+            uploadBuff = tempBuff.get();
+            // Copy sub rectangle out of larger pixel data
+            if (swizzle) {
+                copySubRect<true>(
+                pixels32, updateRectIntersected.x(), updateRectIntersected.y(),
+                uploadBuff, updateRectIntersected.width(), updateRectIntersected.height(), pixelBufferSize.width());
+            } else {
+                copySubRect<false>(
+                pixels32, updateRectIntersected.x(), updateRectIntersected.y(),
+                uploadBuff, updateRectIntersected.width(), updateRectIntersected.height(), pixelBufferSize.width());
+            }
         } else {
-            uploadBuff = copySubRect<false>(
-            pixels32, updateRectIntersected.x(), updateRectIntersected.y(),
-            tempBuff.get(), updateRectIntersected.width(), updateRectIntersected.height(), m_tiles.totalSizeX());
+            uploadBuff = pixels32 + updateRectIntersected.x() + updateRectIntersected.y() * pixelBufferSize.width();
         }
 

trunk/Source/WebCore/platform/graphics/gpu/Texture.h

@@ -43 +43 @@
 
 class IntRect;
+class IntSize;
 
 class Texture : public RefCounted<Texture> {
@@ -52 +53 @@
     void load(void* pixels);
     void updateSubRect(void* pixels, const IntRect&);
+    void updateSubRect(void* pixels, const IntSize&, const IntRect&);
     Format format() const { return m_format; }
     const TilingData& tiles() const { return m_tiles; }

trunk/Source/WebCore/platform/graphics/skia/ImageBufferSkia.cpp

@@ -232 +232 @@
             if (multiplied == Unmultiplied) {
                 unsigned char a = SkGetPackedA32(srcPMColor);
-                destPixel[0] = a ? SkGetPackedR32(srcPMColor) * 255 / a : 0;
-                destPixel[1] = a ? SkGetPackedG32(srcPMColor) * 255 / a : 0;
-                destPixel[2] = a ? SkGetPackedB32(srcPMColor) * 255 / a : 0;
+                unsigned char halfA = a >> 1;
+                destPixel[0] = a ? (SkGetPackedR32(srcPMColor) * 255 + halfA) / a : 0;
+                destPixel[1] = a ? (SkGetPackedG32(srcPMColor) * 255 + halfA) / a : 0;
+                destPixel[2] = a ? (SkGetPackedB32(srcPMColor) * 255 + halfA) / a : 0;
                 destPixel[3] = a;
             } else {
@@ -318 +319 @@
             if (multiplied == Unmultiplied) {
                 unsigned char alpha = srcPixel[3];
-                unsigned char r = SkMulDiv255Ceiling(srcPixel[0], alpha);
-                unsigned char g = SkMulDiv255Ceiling(srcPixel[1], alpha);
-                unsigned char b = SkMulDiv255Ceiling(srcPixel[2], alpha);
+                unsigned char r = SkMulDiv255Round(srcPixel[0], alpha);
+                unsigned char g = SkMulDiv255Round(srcPixel[1], alpha);
+                unsigned char b = SkMulDiv255Round(srcPixel[2], alpha);
                 destRow[x] = SkPackARGB32(alpha, r, g, b);
             } else
@@ -335 +336 @@
 void ImageBuffer::putUnmultipliedImageData(ByteArray* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint)
 {
-    context()->platformContext()->syncSoftwareCanvas();
-    putImageData<Unmultiplied>(source, sourceSize, sourceRect, destPoint, context()->platformContext()->canvas()->getDevice(), m_size);
+    PlatformContextSkia* platformContext = context()->platformContext();
+    if (platformContext->useGPU()) {
+        platformContext->prepareForHardwareDraw();
+        platformContext->gpuCanvas()->putUnmultipliedImageData(source, sourceSize, sourceRect, destPoint);
+        return;
+    }
+    putImageData<Unmultiplied>(source, sourceSize, sourceRect, destPoint, platformContext->canvas()->getDevice(), m_size);
 }
 
 void ImageBuffer::putPremultipliedImageData(ByteArray* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint)
 {
-    context()->platformContext()->syncSoftwareCanvas();
+    PlatformContextSkia* platformContext = context()->platformContext();
+    if (platformContext->useGPU()) {
+        platformContext->prepareForHardwareDraw();
+        platformContext->gpuCanvas()->putPremultipliedImageData(source, sourceSize, sourceRect, destPoint);
+        return;
+    }
     putImageData<Premultiplied>(source, sourceSize, sourceRect, destPoint, context()->platformContext()->canvas()->getDevice(), m_size);
 }