Bug 826093 (Part 1) - Add ClippedImage. r=joe

image/src/ClippedImage.cpp

@@ -0,0 +1,337 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "gfxDrawable.h"
+#include "gfxPlatform.h"
+#include "gfxUtils.h"
+
+#include "ClippedImage.h"
+
+using mozilla::layers::LayerManager;
+using mozilla::layers::ImageContainer;
+
+namespace mozilla {
+namespace image {
+
+class DrawSingleTileCallback : public gfxDrawingCallback
+{
+public:
+  DrawSingleTileCallback(ClippedImage* aImage,
+                         const nsIntRect& aClip,
+                         const nsIntSize& aViewportSize,
+                         const SVGImageContext* aSVGContext,
+                         uint32_t aWhichFrame,
+                         uint32_t aFlags)
+    : mImage(aImage)
+    , mClip(aClip)
+    , mViewportSize(aViewportSize)
+    , mSVGContext(aSVGContext)
+    , mWhichFrame(aWhichFrame)
+    , mFlags(aFlags)
+  {
+    MOZ_ASSERT(mImage, "Must have an image to clip");
+  }
+
+  virtual bool operator()(gfxContext* aContext,
+                          const gfxRect& aFillRect,
+                          const gfxPattern::GraphicsFilter& aFilter,
+                          const gfxMatrix& aTransform)
+  {
+    // Draw the image. |gfxCallbackDrawable| always calls this function with
+    // arguments that guarantee we never tile.
+    mImage->DrawSingleTile(aContext, aFilter, aTransform, aFillRect, mClip,
+                           mViewportSize, mSVGContext, mWhichFrame, mFlags);
+
+    return true;
+  }
+
+private:
+  nsRefPtr<ClippedImage> mImage;
+  const nsIntRect        mClip;
+  const nsIntSize        mViewportSize;
+  const SVGImageContext* mSVGContext;
+  const uint32_t         mWhichFrame;
+  const uint32_t         mFlags;
+};
+
+ClippedImage::ClippedImage(Image* aImage,
+                           nsIntRect aClip)
+  : ImageWrapper(aImage)
+  , mClip(aClip)
+{
+  MOZ_ASSERT(aImage != nullptr, "ClippedImage requires an existing Image");
+}
+
+bool
+ClippedImage::ShouldClip()
+{
+  // We need to evaluate the clipping region against the image's width and height
+  // once they're available to determine if it's valid and whether we actually
+  // need to do any work. We may fail if the image's width and height aren't
+  // available yet, in which case we'll try again later.
+  if (mShouldClip.empty()) {
+    int32_t width, height;
+    if (InnerImage()->HasError()) {
+      // If there's a problem with the inner image we'll let it handle everything.
+      mShouldClip.construct(false);
+    } else if (NS_SUCCEEDED(InnerImage()->GetWidth(&width)) && width > 0 &&
+               NS_SUCCEEDED(InnerImage()->GetHeight(&height)) && height > 0) {
+      // Clamp the clipping region to the size of the underlying image.
+      mClip = mClip.Intersect(nsIntRect(0, 0, width, height));
+
+      // If the clipping region is the same size as the underlying image we
+      // don't have to do anything.
+      mShouldClip.construct(!mClip.IsEqualInterior(nsIntRect(0, 0, width, height)));
+    } else if (InnerImage()->GetStatusTracker().IsLoading()) {
+      // The image just hasn't finished loading yet. We don't yet know whether
+      // clipping with be needed or not for now. Just return without memoizing
+      // anything.
+      return false;
+    } else {
+      // We have a fully loaded image without a clearly defined width and
+      // height. This can happen with SVG images.
+      mShouldClip.construct(false);
+    }
+  }
+
+  MOZ_ASSERT(!mShouldClip.empty(), "Should have computed a result");
+  return mShouldClip.ref();
+}
+
+NS_IMPL_ISUPPORTS1(ClippedImage, imgIContainer)
+
+nsIntRect
+ClippedImage::FrameRect(uint32_t aWhichFrame)
+{
+  if (!ShouldClip()) {
+    return InnerImage()->FrameRect(aWhichFrame);
+  }
+
+  return nsIntRect(0, 0, mClip.width, mClip.height);
+}
+
+NS_IMETHODIMP
+ClippedImage::GetWidth(int32_t* aWidth)
+{
+  if (!ShouldClip()) {
+    return InnerImage()->GetWidth(aWidth);
+  }
+
+  *aWidth = mClip.width;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+ClippedImage::GetHeight(int32_t* aHeight)
+{
+  if (!ShouldClip()) {
+    return InnerImage()->GetHeight(aHeight);
+  }
+
+  *aHeight = mClip.height;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+ClippedImage::GetIntrinsicSize(nsSize* aSize)
+{
+  if (!ShouldClip()) {
+    return InnerImage()->GetIntrinsicSize(aSize);
+  }
+
+  *aSize = nsSize(mClip.width, mClip.height);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+ClippedImage::GetIntrinsicRatio(nsSize* aRatio)
+{
+  if (!ShouldClip()) {
+    return InnerImage()->GetIntrinsicRatio(aRatio);
+  }
+
+  *aRatio = nsSize(mClip.width, mClip.height);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+ClippedImage::GetFrame(uint32_t aWhichFrame,
+                       uint32_t aFlags,
+                       gfxASurface** _retval)
+{
+  if (!ShouldClip()) {
+    return InnerImage()->GetFrame(aWhichFrame, aFlags, _retval);
+  }
+
+  // Create a surface to draw into.
+  gfxImageSurface::gfxImageFormat format = gfxASurface::ImageFormatARGB32;
+  nsRefPtr<gfxASurface> surface = gfxPlatform::GetPlatform()
+    ->CreateOffscreenSurface(gfxIntSize(mClip.width, mClip.height),
+                             gfxImageSurface::ContentFromFormat(format));
+  // Create our callback.
+  nsRefPtr<gfxDrawingCallback> drawTileCallback =
+    new DrawSingleTileCallback(this, mClip, mClip.Size(), nullptr, aWhichFrame, aFlags);
+  nsRefPtr<gfxDrawable> drawable =
+    new gfxCallbackDrawable(drawTileCallback, mClip.Size());
+
+  // Actually draw. The callback will end up invoking DrawSingleTile.
+  nsRefPtr<gfxContext> ctx = new gfxContext(surface);
+  gfxRect imageRect(0, 0, mClip.width, mClip.height);
+  gfxUtils::DrawPixelSnapped(ctx, drawable, gfxMatrix(),
+                             imageRect, imageRect, imageRect, imageRect,
+                             gfxASurface::ImageFormatARGB32, gfxPattern::FILTER_FAST);
+
+  *_retval = surface.forget().get();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+ClippedImage::GetImageContainer(LayerManager* aManager, ImageContainer** _retval)
+{
+  // XXX(seth): We currently don't have a way of clipping the result of
+  // GetImageContainer. We work around this by always returning null, but if it
+  // ever turns out that ClippedImage is widely used on codepaths that can
+  // actually benefit from GetImageContainer, it would be a good idea to fix
+  // that method for performance reasons.
+
+  *_retval = nullptr;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+ClippedImage::ExtractFrame(uint32_t /* aWhichFrame */,
+                           const nsIntRect& /* aRegion */,
+                           uint32_t /* aFlags */,
+                           imgIContainer** /* _retval */)
+{
+  // XXX(seth): This method has to be present in this patch because we haven't
+  // gotten to the point where we can remove ExtractFrame yet, but implementing
+  // it would be a waste of effort.
+  MOZ_ASSERT(false, "ClippedImage::ExtractFrame shouldn't be called");
+  return NS_ERROR_NOT_AVAILABLE;
+}
+
+bool
+ClippedImage::MustCreateSurface(gfxContext* aContext,
+                                const gfxMatrix& aTransform,
+                                const gfxRect& aSourceRect,
+                                const nsIntRect& aSubimage,
+                                const uint32_t aFlags) const
+{
+  gfxRect gfxImageRect(0, 0, mClip.width, mClip.height);
+  nsIntRect intImageRect(0, 0, mClip.width, mClip.height);
+  bool willTile = !gfxImageRect.Contains(aSourceRect) &&
+                  !(aFlags & imgIContainer::FLAG_CLAMP);
+  bool willResample = (aContext->CurrentMatrix().HasNonIntegerTranslation() ||
+                       aTransform.HasNonIntegerTranslation()) &&
+                      (willTile || !aSubimage.Contains(intImageRect));
+  return willTile || willResample;
+}
+
+NS_IMETHODIMP
+ClippedImage::Draw(gfxContext* aContext,
+                   gfxPattern::GraphicsFilter aFilter,
+                   const gfxMatrix& aUserSpaceToImageSpace,
+                   const gfxRect& aFill,
+                   const nsIntRect& aSubimage,
+                   const nsIntSize& aViewportSize,
+                   const SVGImageContext* aSVGContext,
+                   uint32_t aWhichFrame,
+                   uint32_t aFlags)
+{
+  if (!ShouldClip()) {
+    return InnerImage()->Draw(aContext, aFilter, aUserSpaceToImageSpace,
+                              aFill, aSubimage, aViewportSize, aSVGContext,
+                              aWhichFrame, aFlags);
+  }
+
+  // Check for tiling. If we need to tile then we need to create a
+  // gfxCallbackDrawable to handle drawing for us.
+  gfxRect sourceRect = aUserSpaceToImageSpace.Transform(aFill);
+  if (MustCreateSurface(aContext, aUserSpaceToImageSpace, sourceRect, aSubimage, aFlags)) {
+    // Create a temporary surface containing a single tile of this image.
+    // GetFrame will call DrawSingleTile internally.
+    nsRefPtr<gfxASurface> surface;
+    GetFrame(aWhichFrame, aFlags, getter_AddRefs(surface));
+    NS_ENSURE_TRUE(surface, NS_ERROR_FAILURE);
+
+    // Create a drawable from that surface.
+    nsRefPtr<gfxSurfaceDrawable> drawable =
+      new gfxSurfaceDrawable(surface, gfxIntSize(mClip.width, mClip.height));
+
+    // Draw.
+    gfxRect imageRect(0, 0, mClip.width, mClip.height);
+    gfxRect subimage(aSubimage.x, aSubimage.y, aSubimage.width, aSubimage.height);
+    gfxUtils::DrawPixelSnapped(aContext, drawable, aUserSpaceToImageSpace,
+                               subimage, sourceRect, imageRect, aFill,
+                               gfxASurface::ImageFormatARGB32, aFilter);
+
+    return NS_OK;
+  }
+
+  // Determine the appropriate subimage for the inner image.
+  nsIntRect innerSubimage(aSubimage);
+  innerSubimage.MoveBy(mClip.x, mClip.y);
+  innerSubimage.Intersect(mClip);
+
+  return DrawSingleTile(aContext, aFilter, aUserSpaceToImageSpace, aFill, innerSubimage,
+                        aViewportSize, aSVGContext, aWhichFrame, aFlags);
+}
+
+gfxFloat
+ClippedImage::ClampFactor(const gfxFloat aToClamp, const int aReference) const
+{
+  return aToClamp > aReference ? aReference / aToClamp
+                               : 1.0;
+}
+
+nsresult
+ClippedImage::DrawSingleTile(gfxContext* aContext,
+                             gfxPattern::GraphicsFilter aFilter,
+                             const gfxMatrix& aUserSpaceToImageSpace,
+                             const gfxRect& aFill,
+                             const nsIntRect& aSubimage,
+                             const nsIntSize& aViewportSize,
+                             const SVGImageContext* aSVGContext,
+                             uint32_t aWhichFrame,
+                             uint32_t aFlags)
+{
+  MOZ_ASSERT(!MustCreateSurface(aContext, aUserSpaceToImageSpace,
+                                aUserSpaceToImageSpace.Transform(aFill),
+                                aSubimage - nsIntPoint(mClip.x, mClip.y), aFlags),
+             "DrawSingleTile shouldn't need to create a surface");
+
+  // Make the viewport reflect the original image's size.
+  nsIntSize viewportSize(aViewportSize);
+  int32_t imgWidth, imgHeight;
+  if (NS_SUCCEEDED(InnerImage()->GetWidth(&imgWidth)) &&
+      NS_SUCCEEDED(InnerImage()->GetHeight(&imgHeight))) {
+    viewportSize = nsIntSize(imgWidth, imgHeight);
+  } else {
+    MOZ_ASSERT(false, "If ShouldClip() led us to draw then we should never get here");
+  }
+
+  // Add a translation to the transform to reflect the clipping region.
+  gfxMatrix transform(aUserSpaceToImageSpace);
+  transform.Multiply(gfxMatrix().Translate(gfxPoint(mClip.x, mClip.y)));
+
+  // "Clamp the source rectangle" to the clipping region's width and height.
+  // Really, this means modifying the transform to get the results we want.
+  gfxRect sourceRect = transform.Transform(aFill);
+  if (sourceRect.width > mClip.width || sourceRect.height > mClip.height) {
+    gfxMatrix clampSource;
+    clampSource.Translate(gfxPoint(sourceRect.x, sourceRect.y));
+    clampSource.Scale(ClampFactor(sourceRect.width, mClip.width),
+                      ClampFactor(sourceRect.height, mClip.height));
+    clampSource.Translate(gfxPoint(-sourceRect.x, -sourceRect.y));
+    transform.Multiply(clampSource);
+  }
+
+  return InnerImage()->Draw(aContext, aFilter, transform, aFill, aSubimage,
+                            viewportSize, aSVGContext, aWhichFrame, aFlags);
+}
+
+} // namespace image
+} // namespace mozilla

image/src/ClippedImage.h

@@ -0,0 +1,86 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef MOZILLA_IMAGELIB_CLIPPEDIMAGE_H_
+#define MOZILLA_IMAGELIB_CLIPPEDIMAGE_H_
+
+#include "ImageWrapper.h"
+
+namespace mozilla {
+namespace image {
+
+class DrawSingleTileCallback;
+
+/**
+ * An Image wrapper that clips an image against a rectangle. Right now only
+ * absolute coordinates in pixels are supported.
+ *
+ * XXX(seth): There a known (performance, not correctness) issue with
+ * GetImageContainer. See the comments for that method for more information.
+ */
+class ClippedImage : public ImageWrapper
+{
+public:
+  NS_DECL_ISUPPORTS
+
+  virtual ~ClippedImage() { }
+
+  virtual nsIntRect FrameRect(uint32_t aWhichFrame) MOZ_OVERRIDE;
+
+  NS_IMETHOD GetWidth(int32_t* aWidth) MOZ_OVERRIDE;
+  NS_IMETHOD GetHeight(int32_t* aHeight) MOZ_OVERRIDE;
+  NS_IMETHOD GetIntrinsicSize(nsSize* aSize) MOZ_OVERRIDE;
+  NS_IMETHOD GetIntrinsicRatio(nsSize* aRatio) MOZ_OVERRIDE;
+  NS_IMETHOD GetFrame(uint32_t aWhichFrame,
+                      uint32_t aFlags,
+                      gfxASurface** _retval) MOZ_OVERRIDE;
+  NS_IMETHOD GetImageContainer(mozilla::layers::LayerManager* aManager,
+                               mozilla::layers::ImageContainer** _retval) MOZ_OVERRIDE;
+  NS_IMETHOD ExtractFrame(uint32_t aWhichFrame,
+                          const nsIntRect& aRegion,
+                          uint32_t aFlags,
+                          imgIContainer** _retval) MOZ_OVERRIDE;
+  NS_IMETHOD Draw(gfxContext* aContext,
+                  gfxPattern::GraphicsFilter aFilter,
+                  const gfxMatrix& aUserSpaceToImageSpace,
+                  const gfxRect& aFill,
+                  const nsIntRect& aSubimage,
+                  const nsIntSize& aViewportSize,
+                  const SVGImageContext* aSVGContext,
+                  uint32_t aWhichFrame,
+                  uint32_t aFlags) MOZ_OVERRIDE;
+
+protected:
+  ClippedImage(Image* aImage, nsIntRect aClip);
+
+private:
+  bool ShouldClip();
+  bool MustCreateSurface(gfxContext* aContext,
+                         const gfxMatrix& aTransform,
+                         const gfxRect& aSourceRect,
+                         const nsIntRect& aSubimage,
+                         const uint32_t aFlags) const;
+  gfxFloat ClampFactor(const gfxFloat aToClamp, const int aReference) const;
+  nsresult DrawSingleTile(gfxContext* aContext,
+                          gfxPattern::GraphicsFilter aFilter,
+                          const gfxMatrix& aUserSpaceToImageSpace,
+                          const gfxRect& aFill,
+                          const nsIntRect& aSubimage,
+                          const nsIntSize& aViewportSize,
+                          const SVGImageContext* aSVGContext,
+                          uint32_t aWhichFrame,
+                          uint32_t aFlags);
+
+  nsIntRect   mClip;              // The region to clip to.
+  Maybe<bool> mShouldClip;        // Memoized ShouldClip() if present.
+
+  friend class DrawSingleTileCallback;
+  friend class ImageFactory;
+};
+
+} // namespace image
+} // namespace mozilla
+
+#endif // MOZILLA_IMAGELIB_CLIPPEDIMAGE_H_

image/src/Makefile.in

@@ -27,6 +27,7 @@ CPPSRCS		= \
 			ImageFactory.cpp \
                         ImageMetadata.cpp \
 			ImageWrapper.cpp \
+			ClippedImage.cpp \
 			Decoder.cpp \
 			DiscardTracker.cpp \
 			FrozenImage.cpp \