Changeset 34210 in webkit

Timestamp:

May 29, 2008 2:05:11 PM (16 years ago)

Author:

hyatt@apple.com

Message:

2008-05-29 David Hyatt <​hyatt@apple.com>

Improve the performance of the GUIMark benchmark by 2x in the CoreGraphics code path.

Whenever a foreground image changes size rapidly, we will now dynamically shift into rendering it
using low quality scaling. Once the animation completes, the image will repaint at high quality.
Scaled images will still render at high quality by default, only shifting into low quality if
the scale factor is rapidly changing. This change raises GUIMark from 21fps to 34fps on my machine.

Rewrite the Image draw method to avoid the use of throwaway CG subimages. Instead the entire image is
always drawn (with the appropriate clip and scale set up to make sure the correct subimage portion shows up
in the destination rect). This change raises GUIMark from 34fps to 43fps on my machine.

Reviewed by Darin

• platform/graphics/GraphicsContext.cpp: (WebCore::GraphicsContext::drawImage):
• platform/graphics/cg/ImageCG.cpp: (WebCore::BitmapImage::draw):
• rendering/RenderImage.cpp: (WebCore::RenderImageScaleData::RenderImageScaleData): (WebCore::RenderImageScaleData::~RenderImageScaleData): (WebCore::RenderImageScaleData::size): (WebCore::RenderImageScaleData::time): (WebCore::RenderImageScaleData::useLowQualityScale): (WebCore::RenderImageScaleData::hiqhQualityRepaintTimer): (WebCore::RenderImageScaleData::setSize): (WebCore::RenderImageScaleData::setTime): (WebCore::RenderImageScaleData::setUseLowQualityScale): (WebCore::RenderImageScaleObserver::shouldImagePaintAtLowQuality): (WebCore::RenderImageScaleObserver::imageDestroyed): (WebCore::RenderImageScaleObserver::highQualityRepaintTimerFired): (WebCore::RenderImage::highQualityRepaintTimerFired): (WebCore::RenderImage::~RenderImage): (WebCore::RenderImage::paintReplaced):
• rendering/RenderImage.h:

Location:

trunk/WebCore

Files:

• ChangeLog (modified) (1 diff)
• platform/graphics/BitmapImage.h (modified) (1 diff)
• platform/graphics/GraphicsContext.cpp (modified) (2 diffs)
• platform/graphics/Image.h (modified) (1 diff)
• platform/graphics/cg/ImageCG.cpp (modified) (3 diffs)
• rendering/RenderImage.cpp (modified) (3 diffs)
• rendering/RenderImage.h (modified) (2 diffs)

trunk/WebCore/ChangeLog

@@ +1 @@
+2008-05-29  David Hyatt  <hyatt@apple.com>
+
+        Improve the performance of the GUIMark benchmark by 2x in the CoreGraphics code path.
+
+        Whenever a foreground image changes size rapidly, we will now dynamically shift into rendering it
+        using low quality scaling.  Once the animation completes, the image will repaint at high quality.
+        Scaled images will still render at high quality by default, only shifting into low quality if
+        the scale factor is rapidly changing.  This change raises GUIMark from 21fps to 34fps on my machine.
+
+        Rewrite the Image draw method to avoid the use of throwaway CG subimages.  Instead the entire image is
+        always drawn (with the appropriate clip and scale set up to make sure the correct subimage portion shows up
+        in the destination rect).  This change raises GUIMark from 34fps to 43fps on my machine.
+
+        Reviewed by Darin
+
+        * platform/graphics/GraphicsContext.cpp:
+        (WebCore::GraphicsContext::drawImage):
+        * platform/graphics/cg/ImageCG.cpp:
+        (WebCore::BitmapImage::draw):
+        * rendering/RenderImage.cpp:
+        (WebCore::RenderImageScaleData::RenderImageScaleData):
+        (WebCore::RenderImageScaleData::~RenderImageScaleData):
+        (WebCore::RenderImageScaleData::size):
+        (WebCore::RenderImageScaleData::time):
+        (WebCore::RenderImageScaleData::useLowQualityScale):
+        (WebCore::RenderImageScaleData::hiqhQualityRepaintTimer):
+        (WebCore::RenderImageScaleData::setSize):
+        (WebCore::RenderImageScaleData::setTime):
+        (WebCore::RenderImageScaleData::setUseLowQualityScale):
+        (WebCore::RenderImageScaleObserver::shouldImagePaintAtLowQuality):
+        (WebCore::RenderImageScaleObserver::imageDestroyed):
+        (WebCore::RenderImageScaleObserver::highQualityRepaintTimerFired):
+        (WebCore::RenderImage::highQualityRepaintTimerFired):
+        (WebCore::RenderImage::~RenderImage):
+        (WebCore::RenderImage::paintReplaced):
+        * rendering/RenderImage.h:
+
 2008-05-29  Justin Garcia  <justin.garcia@apple.com>
 

trunk/WebCore/platform/graphics/BitmapImage.h

@@ -100 +100 @@
     ~BitmapImage();
     
+    virtual bool isBitmapImage() const { return true; }
+    
     virtual IntSize size() const;
 

trunk/WebCore/platform/graphics/GraphicsContext.cpp

@@ -330 +330 @@
 }
 
-static const int cInterpolationCutoff = 800 * 800;
-
 void GraphicsContext::drawImage(Image* image, const FloatRect& dest, const FloatRect& src, CompositeOperator op, bool useLowQualityScale)
 {
@@ -352 +350 @@
         th = image->height();
 
-    bool shouldUseLowQualityInterpolation = useLowQualityScale && (tsw != tw || tsh != th) && tsw * tsh > cInterpolationCutoff;
-    if (shouldUseLowQualityInterpolation) {
+    if (useLowQualityScale) {
         save();
         setUseLowQualityImageInterpolation(true);
     }
     image->draw(this, FloatRect(dest.location(), FloatSize(tw, th)), FloatRect(src.location(), FloatSize(tsw, tsh)), op);
-    if (shouldUseLowQualityInterpolation)
+    if (useLowQualityScale)
         restore();
 }

trunk/WebCore/platform/graphics/Image.h

@@ -80 +80 @@
     static bool supportsType(const String&); 
 
+    virtual bool isBitmapImage() const { return false; }
+    
     bool isNull() const;
 

trunk/WebCore/platform/graphics/cg/ImageCG.cpp

@@ -127 +127 @@
 }
 
-void BitmapImage::draw(GraphicsContext* ctxt, const FloatRect& dstRect, const FloatRect& srcRect, CompositeOperator compositeOp)
-{
-    CGRect fr = ctxt->roundToDevicePixels(srcRect);
-    CGRect ir = ctxt->roundToDevicePixels(dstRect);
-
+void BitmapImage::draw(GraphicsContext* ctxt, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator compositeOp)
+{
     CGImageRef image = frameAtIndex(m_currentFrame);
     if (!image) // If it's too early we won't have an image yet.
@@ -137 +134 @@
     
     if (mayFillWithSolidColor()) {
-        fillWithSolidColor(ctxt, ir, solidColor(), compositeOp);
-        return;
-    }
-
-    // Get the height (in adjusted, i.e. scaled, coords) of the portion of the image
-    // that is currently decoded.  This could be less that the actual height.
-    CGSize selfSize = size();                          // full image size, in pixels
-    float curHeight = CGImageGetHeight(image);         // height of loaded portion, in pixels
-    
-    CGSize adjustedSize = selfSize;
-    if (curHeight < selfSize.height) {
-        adjustedSize.height *= curHeight / selfSize.height;
-
-        // Is the amount of available bands less than what we need to draw?  If so,
-        // we may have to clip 'fr' if it goes outside the available bounds.
-        if (CGRectGetMaxY(fr) > adjustedSize.height) {
-            float frHeight = adjustedSize.height - fr.origin.y; // clip fr to available bounds
-            if (frHeight <= 0)
-                return;                                             // clipped out entirely
-            ir.size.height *= (frHeight / fr.size.height);    // scale ir proportionally to fr
-            fr.size.height = frHeight;
-        }
+        fillWithSolidColor(ctxt, destRect, solidColor(), compositeOp);
+        return;
     }
 
@@ -164 +141 @@
     ctxt->save();
 
+    // If the source rect is a subportion of the image, then we compute an inflated destination rect that will hold the entire image
+    // and then set a clip to the portion that we want to display.
+    CGSize selfSize = size();
+    FloatRect adjustedDestRect = destRect;
+    if (srcRect.width() != selfSize.width || srcRect.height() != selfSize.height) {
+        // A subportion of the image is drawing.  Adjust the destination rect to
+        // account for this.
+        float xScale = srcRect.width() / destRect.width();
+        float yScale = srcRect.height() / destRect.height();
+        
+        adjustedDestRect.setLocation(FloatPoint(destRect.x() - srcRect.x() / xScale, destRect.y() - srcRect.y() / yScale));
+        adjustedDestRect.setSize(FloatSize(size().width() / xScale, size().height() / yScale));
+        
+        CGContextClipToRect(context, destRect);
+    }
+
+    // If the image is only partially loaded, then shrink the destination rect that we're drawing into accordingly.
+    float currHeight = CGImageGetHeight(image);
+    if (currHeight < selfSize.height)
+        adjustedDestRect.setHeight(adjustedDestRect.height() * currHeight / selfSize.height);
+
     // Flip the coords.
     ctxt->setCompositeOperation(compositeOp);
-    CGContextTranslateCTM(context, ir.origin.x, ir.origin.y + ir.size.height);
+    CGContextTranslateCTM(context, adjustedDestRect.x(), adjustedDestRect.bottom());
     CGContextScaleCTM(context, 1, -1);
-
-    // Translated to origin, now draw at 0,0.
-    ir.origin.x = ir.origin.y = 0;
-    
-    // If we're drawing a sub portion of the image then create
-    // a image for the sub portion and draw that.
-    // Test using example site at http://www.meyerweb.com/eric/css/edge/complexspiral/demo.html
-    if (fr.size.width != adjustedSize.width || fr.size.height != adjustedSize.height) {
-        // Convert ft to image pixel coords:
-        float xscale = adjustedSize.width / selfSize.width;
-        float yscale = adjustedSize.height / curHeight;     // yes, curHeight, not selfSize.height!
-        fr.origin.x /= xscale;
-        fr.origin.y /= yscale;
-        fr.size.width /= xscale;
-        fr.size.height /= yscale;
-        
-        image = CGImageCreateWithImageInRect(image, fr);
-        if (image) {
-            CGContextDrawImage(context, ir, image);
-            CFRelease(image);
-        }
-    } else // Draw the whole image.
-        CGContextDrawImage(context, ir, image);
+    adjustedDestRect.setLocation(FloatPoint());
+
+    // Draw the image.
+    CGContextDrawImage(context, adjustedDestRect, image);
         
     ctxt->restore();

trunk/WebCore/rendering/RenderImage.cpp

@@ -37 +37 @@
 #include "Page.h"
 #include "RenderView.h"
+#include "SystemTime.h"
 
 using namespace std;
 
 namespace WebCore {
+
+static const double cInterpolationCutoff = 800. * 800.;
+static const double cLowQualityTimeThreshold = 0.050; // 50 ms
+
+class RenderImageScaleData {
+public:
+    RenderImageScaleData(RenderImage* image, const IntSize& size, double time, bool lowQualityScale)
+        : m_size(size)
+        , m_time(time)
+        , m_lowQualityScale(lowQualityScale)
+        , m_highQualityRepaintTimer(image, &RenderImage::highQualityRepaintTimerFired)
+    {
+    }
+
+    ~RenderImageScaleData()
+    {
+        m_highQualityRepaintTimer.stop();
+    }
+    
+    const IntSize& size() const { return m_size; }
+    double time() const { return m_time; }
+    bool useLowQualityScale() const { return m_lowQualityScale; }
+    Timer<RenderImage>& hiqhQualityRepaintTimer() { return m_highQualityRepaintTimer; }
+
+    void setSize(const IntSize& s) { m_size = s; }
+    void setTime(double t) { m_time = t; }
+    void setUseLowQualityScale(bool b)
+    {
+        m_highQualityRepaintTimer.stop();
+        m_lowQualityScale = b;
+        if (b)
+            m_highQualityRepaintTimer.startOneShot(cLowQualityTimeThreshold);
+    }
+    
+private:
+    IntSize m_size;
+    double m_time;
+    bool m_lowQualityScale;
+    Timer<RenderImage> m_highQualityRepaintTimer;
+};
+
+class RenderImageScaleObserver
+{
+public:
+    static bool shouldImagePaintAtLowQuality(RenderImage*, const IntSize&);
+
+    static void imageDestroyed(RenderImage* image)
+    {
+        if (gImages) {
+            RenderImageScaleData* data = gImages->take(image);
+            delete data;
+            if (gImages->size() == 0) {
+                delete gImages;
+                gImages = 0;
+            }
+        }
+    }
+    
+    static void highQualityRepaintTimerFired(RenderImage* image)
+    {
+        RenderImageScaleObserver::imageDestroyed(image);
+        image->repaint();
+    }
+    
+    static HashMap<RenderImage*, RenderImageScaleData*>* gImages;
+};
+
+bool RenderImageScaleObserver::shouldImagePaintAtLowQuality(RenderImage* image, const IntSize& size)
+{
+    // If the image is not a bitmap image, then none of this is relevant and we just paint at high
+    // quality.
+    if (!image->image() || !image->image()->isBitmapImage())
+        return false;
+
+    // Make sure to use the unzoomed image size, since if a full page zoom is in effect, the image
+    // is actually being scaled.
+    IntSize imageSize(image->image()->width(), image->image()->height());
+
+    // Look ourselves up in the hashtable.
+    RenderImageScaleData* data = 0;
+    if (gImages)
+        data = gImages->get(image);
+
+    if (imageSize == size) {
+        // There is no scale in effect.  If we had a scale in effect before, we can just delete this data.
+        if (data) {
+            gImages->remove(image);
+            delete data;
+        }
+        return false;
+    }
+
+    // There is no need to hash scaled images that always use low quality mode when the page demands it.  This is the iChat case.
+    if (image->document()->page()->inLowQualityImageInterpolationMode()) {
+        double totalPixels = static_cast<double>(image->image()->width()) * static_cast<double>(image->image()->height());
+        if (totalPixels > cInterpolationCutoff)
+            return true;
+    }
+
+    // If there is no data yet, we will paint the first scale at high quality and record the paint time in case a second scale happens
+    // very soon.
+    if (!data) {
+        data = new RenderImageScaleData(image, size, currentTime(), false);
+        if (!gImages)
+            gImages = new HashMap<RenderImage*, RenderImageScaleData*>;
+        gImages->set(image, data);
+        return false;
+    }
+
+    // We are scaled, but we painted already at this size, so just keep using whatever mode we last painted with.
+    if (data->size() == size)
+        return data->useLowQualityScale();
+
+    // We have data and our size just changed.  If this change happened quickly, go into low quality mode and then set a repaint
+    // timer to paint in high quality mode.  Otherwise it is ok to just paint in high quality mode.
+    double newTime = currentTime();
+    data->setUseLowQualityScale(newTime - data->time() < cLowQualityTimeThreshold);
+    data->setTime(newTime);
+    data->setSize(size);
+    return data->useLowQualityScale();
+}
+
+HashMap<RenderImage*, RenderImageScaleData*>* RenderImageScaleObserver::gImages = 0;
+
+void RenderImage::highQualityRepaintTimerFired(Timer<RenderImage>* timer)
+{
+    RenderImageScaleObserver::highQualityRepaintTimerFired(this);
+}
 
 using namespace HTMLNames;
@@ -55 +184 @@
     if (m_cachedImage)
         m_cachedImage->removeClient(this);
+    RenderImageScaleObserver::imageDestroyed(this);
 }
 
@@ -255 +385 @@
 #endif
 
-        IntRect rect(IntPoint(tx + leftBorder + leftPad, ty + topBorder + topPad), IntSize(cWidth, cHeight));
-
+        IntSize contentSize(cWidth, cHeight);
+        bool useLowQualityScaling = RenderImageScaleObserver::shouldImagePaintAtLowQuality(this, contentSize);
+        IntRect rect(IntPoint(tx + leftBorder + leftPad, ty + topBorder + topPad), contentSize);
         HTMLImageElement* imageElt = (element() && element()->hasTagName(imgTag)) ? static_cast<HTMLImageElement*>(element()) : 0;
         CompositeOperator compositeOperator = imageElt ? imageElt->compositeOperator() : CompositeSourceOver;
-        context->drawImage(image(cWidth, cHeight), rect, compositeOperator, document()->page()->inLowQualityImageInterpolationMode());
+        context->drawImage(image(cWidth, cHeight), rect, compositeOperator, useLowQualityScaling);
     }
 }

trunk/WebCore/rendering/RenderImage.h

@@ -69 +69 @@
     virtual bool hasImage() const { return m_cachedImage; }
 
+    void highQualityRepaintTimerFired(Timer<RenderImage>*);
+
 protected:
     virtual Image* image(int w = 0, int h = 0) { return m_cachedImage ? m_cachedImage->image() : nullImage(); }
@@ -96 +98 @@
 
     static Image* nullImage();
+    
+    friend class RenderImageScaleObserver;
 };