Fixing src rectangle clipping with drawImage

Source/core/html/canvas/CanvasRenderingContext2D.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
@@ skipping 1173 matching lines @@
 }
 
 static inline FloatRect normalizeRect(const FloatRect& rect)
 {
     return FloatRect(min(rect.x(), rect.maxX()),
         min(rect.y(), rect.maxY()),
         max(rect.width(), -rect.width()),
         max(rect.height(), -rect.height()));
 }
 
+static inline void clipRectsToImageRect(const FloatRect& imageRect, FloatRect& srcRect, FloatRect& dstRect)

[Stephen White, 2013/07/22 22:02:06]

Just personal style, but when it comes to arguments, I prefer non-const pointers
over non-const references. It makes it easier to see what may be modified at the
call site. (Code style doesn't say either way, though, so I won't stop you.)

[Justin Novosad, 2013/07/23 17:38:34]

Done.

+{
+    if (imageRect.contains(srcRect))
+        return;
+
+    // Compute the src to dst transform
+    FloatSize scale(dstRect.size().width() / srcRect.size().width(), dstRect.size().height() / srcRect.size().height());
+    FloatPoint scaledSrcLocation = srcRect.location();
+    scaledSrcLocation.scale(scale.width(), scale.height());
+    FloatSize offset = dstRect.location() - scaledSrcLocation;
+
+    srcRect.intersect(imageRect);
+
+    // To clip the destination rectangle in the same proportion, transform the clipped src rect
+    dstRect = srcRect;
+    dstRect.scale(scale.width(), scale.height());
+    dstRect.move(offset);
+}
+
 void CanvasRenderingContext2D::drawImageInternal(Image* image, const FloatRect& srcRect, const FloatRect& dstRect, const CompositeOperator& op, const BlendMode& blendMode)
 {
     if (!image)
         return;
 
     GraphicsContext* c = drawingContext();
     if (!c)
         return;
     if (!state().m_invertibleCTM)
         return;
@@ skipping 61 matching lines @@
     FloatRect normalizedDstRect = normalizeRect(dstRect);
     FloatRect actualDstRect(FloatPoint(bitmap->bitmapOffset()), bitmap->bitmapSize());
     actualDstRect.scale(normalizedDstRect.width() / bitmap->width(), normalizedDstRect.height() / bitmap->height());
     actualDstRect.moveBy(normalizedDstRect.location());
 
     FloatRect imageRect = FloatRect(FloatPoint(), bitmap->bitmapSize());
     if (!srcRect.width() || !srcRect.height()) {
         ec = IndexSizeError;
         return;
     }
-    if (!imageRect.contains(normalizedSrcRect))
+    if (!imageRect.intersects(normalizedSrcRect))
         return;
 
+    clipRectsToImageRect(imageRect, normalizedSrcRect, actualDstRect);
+
     Image* imageForRendering = bitmap->bitmapImage();
 
     drawImageInternal(imageForRendering, normalizedSrcRect, actualDstRect, state().m_globalComposite, state().m_globalBlend);
 }
 
 void CanvasRenderingContext2D::drawImage(HTMLImageElement* image, float x, float y, ExceptionCode& ec)
 {
     if (!image) {
         ec = TypeMismatchError;
         return;
@@ skipping 45 matching lines @@
         return;
 
     FloatRect normalizedSrcRect = normalizeRect(srcRect);
     FloatRect normalizedDstRect = normalizeRect(dstRect);
 
     FloatRect imageRect = FloatRect(FloatPoint(), size(image));
     if (!srcRect.width() || !srcRect.height()) {
         ec = IndexSizeError;
         return;
     }
-    if (!imageRect.contains(normalizedSrcRect))
+    if (!imageRect.intersects(normalizedSrcRect))
         return;
 
+    clipRectsToImageRect(imageRect, normalizedSrcRect, normalizedDstRect);
+
     CachedImage* cachedImage = image->cachedImage();
     if (!cachedImage)
         return;
 
     checkOrigin(image);
 
     Image* imageForRendering = cachedImage->imageForRenderer(image->renderer());
 
     // For images that depend on an unavailable container size, we need to fall back to the intrinsic
     // object size. http://www.w3.org/TR/2dcontext2/#dom-context-2d-drawimage
@@ skipping 37 matching lines @@
         return;
     }
 
     if (!srcRect.width() || !srcRect.height()) {
         ec = IndexSizeError;
         return;
     }
 
     ec = 0;
 
-    if (!srcCanvasRect.contains(normalizeRect(srcRect)) || !dstRect.width() || !dstRect.height())
+    FloatRect normalizedSrcRect = normalizeRect(srcRect);
+    FloatRect normalizedDstRect = normalizeRect(dstRect);
+
+    if (!srcCanvasRect.intersects(normalizedSrcRect) || !normalizedDstRect.width() || !normalizedDstRect.height())
         return;
 
+    clipRectsToImageRect(srcCanvasRect, normalizedSrcRect, normalizedDstRect);
+
     GraphicsContext* c = drawingContext();
     if (!c)
         return;
     if (!state().m_invertibleCTM)
         return;
 
     // FIXME: Do this through platform-independent GraphicsContext API.
     ImageBuffer* buffer = sourceCanvas->buffer();
     if (!buffer)
         return;
 
     checkOrigin(sourceCanvas);
 
     // If we're drawing from one accelerated canvas 2d to another, avoid calling sourceCanvas->makeRenderingResultsAvailable()
     // as that will do a readback to software.
     CanvasRenderingContext* sourceContext = sourceCanvas->renderingContext();
     // FIXME: Implement an accelerated path for drawing from a WebGL canvas to a 2d canvas when possible.
     if (!isAccelerated() || !sourceContext || !sourceContext->isAccelerated() || !sourceContext->is2d())
         sourceCanvas->makeRenderingResultsAvailable();
 
-    if (rectContainsCanvas(dstRect)) {
-        c->drawImageBuffer(buffer, dstRect, srcRect, state().m_globalComposite, state().m_globalBlend);
+    if (rectContainsCanvas(normalizedDstRect)) {
+        c->drawImageBuffer(buffer, normalizedDstRect, normalizedSrcRect, state().m_globalComposite, state().m_globalBlend);
         didDrawEntireCanvas();
     } else if (isFullCanvasCompositeMode(state().m_globalComposite)) {
-        fullCanvasCompositedDrawImage(buffer, dstRect, srcRect, state().m_globalComposite);
+        fullCanvasCompositedDrawImage(buffer, normalizedDstRect, normalizedSrcRect, state().m_globalComposite);
         didDrawEntireCanvas();
     } else if (state().m_globalComposite == CompositeCopy) {
         clearCanvas();
-        c->drawImageBuffer(buffer, dstRect, srcRect, state().m_globalComposite, state().m_globalBlend);
+        c->drawImageBuffer(buffer, normalizedDstRect, normalizedSrcRect, state().m_globalComposite, state().m_globalBlend);
         didDrawEntireCanvas();
     } else {
-        c->drawImageBuffer(buffer, dstRect, srcRect, state().m_globalComposite, state().m_globalBlend);
-        didDraw(dstRect);
+        c->drawImageBuffer(buffer, normalizedDstRect, normalizedSrcRect, state().m_globalComposite, state().m_globalBlend);
+        didDraw(normalizedDstRect);
     }
 }
 
 void CanvasRenderingContext2D::drawImage(HTMLVideoElement* video, float x, float y, ExceptionCode& ec)
 {
     if (!video) {
         ec = TypeMismatchError;
         return;
     }
     IntSize s = size(video);
@@ skipping 30 matching lines @@
 
     if (video->readyState() == HTMLMediaElement::HAVE_NOTHING || video->readyState() == HTMLMediaElement::HAVE_METADATA)
         return;
 
     FloatRect videoRect = FloatRect(FloatPoint(), size(video));
     if (!srcRect.width() || !srcRect.height()) {
         ec = IndexSizeError;
         return;
     }
 
-    if (!videoRect.contains(normalizeRect(srcRect)) || !dstRect.width() || !dstRect.height())
+    FloatRect normalizedSrcRect = normalizeRect(srcRect);
+    FloatRect normalizedDstRect = normalizeRect(dstRect);
+
+    if (!videoRect.intersects(normalizeRect(normalizedSrcRect)) || !normalizedDstRect.width() || !normalizedDstRect.height())

[aandrey, 2013/07/23 09:25:40]

remove redundant normalizeRect() call?

[Justin Novosad, 2013/07/23 17:38:34]

Done.

         return;
 
+    clipRectsToImageRect(videoRect, normalizedSrcRect, normalizedDstRect);
+
     GraphicsContext* c = drawingContext();
     if (!c)
         return;
     if (!state().m_invertibleCTM)
         return;
 
     checkOrigin(video);
 
     GraphicsContextStateSaver stateSaver(*c);
-    c->clip(dstRect);
-    c->translate(dstRect.x(), dstRect.y());
-    c->scale(FloatSize(dstRect.width() / srcRect.width(), dstRect.height() / srcRect.height()));
-    c->translate(-srcRect.x(), -srcRect.y());
+    c->clip(normalizedDstRect);
+    c->translate(normalizedDstRect.x(), normalizedDstRect.y());
+    c->scale(FloatSize(normalizedDstRect.width() / normalizedSrcRect.width(), normalizedDstRect.height() / normalizedSrcRect.height()));
+    c->translate(-normalizedSrcRect.x(), -normalizedSrcRect.y());
     video->paintCurrentFrameInContext(c, IntRect(IntPoint(), size(video)));
     stateSaver.restore();
     didDraw(dstRect);
 }
 
 void CanvasRenderingContext2D::drawImageFromRect(HTMLImageElement* image,
     float sx, float sy, float sw, float sh,
     float dx, float dy, float dw, float dh,
     const String& compositeOperation)
 {
@@ skipping 786 matching lines @@
 }
 
 PassRefPtr<Canvas2DContextAttributes> CanvasRenderingContext2D::getContextAttributes() const
 {
     RefPtr<Canvas2DContextAttributes> attributes = Canvas2DContextAttributes::create();
     attributes->setAlpha(m_hasAlpha);
     return attributes.release();
 }
 
 } // namespace WebCore