Implement ImageBitmapOptions resize

third_party/WebKit/Source/core/frame/ImageBitmap.cpp

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/frame/ImageBitmap.h"
 
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
 #include "platform/graphics/skia/SkiaUtils.h"
@@ skipping 99 matching lines @@
     SkBitmap bitmap = frame->bitmap();
     if (!frameIsValid(bitmap))
         return nullptr;
     return fromSkSp(SkImage::MakeFromBitmap(bitmap));
 }
 
 // The parameter imageFormat indicates whether the first parameter "image" is unpremultiplied or not.
 // imageFormat = PremultiplyAlpha means the image is in premuliplied format
 // For example, if the image is already in unpremultiplied format and we want the created ImageBitmap
 // in the same format, then we don't need to use the ImageDecoder to decode the image.
-static PassRefPtr<StaticBitmapImage> cropImage(Image* image, const IntRect& cropRect, bool flipY, bool premultiplyAlpha, AlphaDisposition imageFormat = PremultiplyAlpha, ImageDecoder::GammaAndColorProfileOption colorSpaceOp = ImageDecoder::GammaAndColorProfileApplied)
+static PassRefPtr<StaticBitmapImage> cropImage(Image* image, IntRect& cropRect, bool flipY, bool premultiplyAlpha, AlphaDisposition imageFormat = PremultiplyAlpha, ImageDecoder::GammaAndColorProfileOption colorSpaceOp = ImageDecoder::GammaAndColorProfileApplied)
 {
     ASSERT(image);
 
     IntRect imgRect(IntPoint(), IntSize(image->width(), image->height()));
     const IntRect srcRect = intersection(imgRect, cropRect);
 
     // In the case when cropRect doesn't intersect the source image and it requires a umpremul image
     // We immediately return a transparent black image with cropRect.size()
     if (srcRect.isEmpty() && !premultiplyAlpha) {
         SkImageInfo info = SkImageInfo::Make(cropRect.width(), cropRect.height(), kN32_SkColorType, kUnpremul_SkAlphaType);
@@ skipping 45 matching lines @@
         skiaImage = flipSkImageVertically(skiaImage.get(), PremultiplyAlpha);
 
     if (premultiplyAlpha) {
         if (imageFormat == PremultiplyAlpha)
             return StaticBitmapImage::create(unPremulSkImageToPremul(skiaImage.get()));
         return StaticBitmapImage::create(skiaImage.release());
     }
     return StaticBitmapImage::create(premulSkImageToUnPremul(skiaImage.get()));
 }
 
-ImageBitmap::ImageBitmap(HTMLImageElement* image, const IntRect& cropRect, Document* document, const ImageBitmapOptions& options)
+static PassRefPtr<Image> scaleInput(Image* input, unsigned resizeWidth, unsigned resizeHeight, SkFilterQuality resizeQuality)
+{
+    RefPtr<SkImage> skiaImage = input->imageForCurrentFrame();
+    SkImageInfo scaledInfo = SkImageInfo::MakeN32Premul(resizeWidth, resizeHeight);
+    std::unique_ptr<uint8_t[]> scaledPixels = wrapArrayUnique(new uint8_t[resizeWidth * resizeHeight * scaledInfo.bytesPerPixel()]);
+    SkPixmap scaledPixmap(scaledInfo, scaledPixels.release(), scaledInfo.minRowBytes());
+    if (!skiaImage->scalePixels(scaledPixmap, resizeQuality))
+        return nullptr;
+    RefPtr<SkImage> scaledImage = fromSkSp(SkImage::MakeFromRaster(scaledPixmap, [](const void* pixels, void*)

[jbroman, 2016/06/29 21:14:41]

Doing a special pixmap allocation here seems slightly weird, given that we don't
particularly need to control the allocation. Why not use
SkSurface::NewRasterN32, drawBitmapRect into that surface, and then taking a
snapshot from that? It seems equivalent (this is roughly what scalePixels seems
to do internally), but doesn't make this code manage the allocation as much.

(Disregard if Skia people have told you not to do that, obviously.)

(There's also skia::ImageOperations::Resize, but I think new uses of it are
mildly discouraged.)

[xidachen, 2016/06/30 15:23:11]

Done.

+        {
+            delete[] static_cast<const uint8_t*>(pixels);
+        }, nullptr));
+    return StaticBitmapImage::create(scaledImage);
+}
+
+static void scaleCropRect(IntRect& cropRect, int width, int height, unsigned resizeWidth, unsigned resizeHeight)
+{
+    if (cropRect.x() == 0 && cropRect.y() == 0 && cropRect.width() == width && cropRect.height() == height) {
+        cropRect.setWidth(resizeWidth);
+        cropRect.setHeight(resizeHeight);
+    }
+}
+
+ImageBitmap::ImageBitmap(HTMLImageElement* image, IntRect& cropRect, Document* document, const ImageBitmapOptions& options)
 {
     bool flipY;
     bool premultiplyAlpha;
-    parseOptions(options, flipY, premultiplyAlpha);
+    unsigned resizeWidth = 0;
+    unsigned resizeHeight = 0;
+    SkFilterQuality resizeQuality = kLow_SkFilterQuality;
+    parseOptions(options, flipY, premultiplyAlpha, resizeWidth, resizeHeight, resizeQuality);
+
+    RefPtr<Image> input = image->cachedImage()->getImage();
+    if (options.hasResizeWidth() && options.hasResizeHeight()
+        && (static_cast<int>(resizeWidth) != input->width() || static_cast<int>(resizeHeight) != input->height())) {
+        scaleCropRect(cropRect, input->width(), input->height(), resizeWidth, resizeHeight);
+        input = scaleInput(input.get(), resizeWidth, resizeHeight, resizeQuality);
+    }
 
     if (options.colorSpaceConversion() == "none")
-        m_image = cropImage(image->cachedImage()->getImage(), cropRect, flipY, premultiplyAlpha, PremultiplyAlpha, ImageDecoder::GammaAndColorProfileIgnored);
+        m_image = cropImage(input.get(), cropRect, flipY, premultiplyAlpha, PremultiplyAlpha, ImageDecoder::GammaAndColorProfileIgnored);
     else
-        m_image = cropImage(image->cachedImage()->getImage(), cropRect, flipY, premultiplyAlpha, PremultiplyAlpha, ImageDecoder::GammaAndColorProfileApplied);
+        m_image = cropImage(input.get(), cropRect, flipY, premultiplyAlpha, PremultiplyAlpha, ImageDecoder::GammaAndColorProfileApplied);
     if (!m_image)
         return;
     // In the case where the source image is lazy-decoded, m_image may not be in
     // a decoded state, we trigger it here.
     RefPtr<SkImage> skImage = m_image->imageForCurrentFrame();
     SkPixmap pixmap;
     if (!skImage->isTextureBacked() && !skImage->peekPixels(&pixmap)) {
         sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(skImage->width(), skImage->height());
         surface->getCanvas()->drawImage(skImage.get(), 0, 0);
         m_image = StaticBitmapImage::create(fromSkSp(surface->makeImageSnapshot()));
     }
     m_image->setOriginClean(!image->wouldTaintOrigin(document->getSecurityOrigin()));
     m_image->setPremultiplied(premultiplyAlpha);
 }
 
-ImageBitmap::ImageBitmap(HTMLVideoElement* video, const IntRect& cropRect, Document* document, const ImageBitmapOptions& options)
+ImageBitmap::ImageBitmap(HTMLVideoElement* video, IntRect& cropRect, Document* document, const ImageBitmapOptions& options)
 {
     IntSize playerSize;
     if (video->webMediaPlayer())
         playerSize = video->webMediaPlayer()->naturalSize();
 
     IntRect videoRect = IntRect(IntPoint(), playerSize);
     IntRect srcRect = intersection(cropRect, videoRect);
     std::unique_ptr<ImageBuffer> buffer = ImageBuffer::create(cropRect.size(), NonOpaque, DoNotInitializeImagePixels);
     if (!buffer)
         return;
 
     IntPoint dstPoint = IntPoint(std::max(0, -cropRect.x()), std::max(0, -cropRect.y()));
     video->paintCurrentFrame(buffer->canvas(), IntRect(dstPoint, srcRect.size()), nullptr);
 
     bool flipY;
     bool premultiplyAlpha;
-    parseOptions(options, flipY, premultiplyAlpha);
+    unsigned resizeWidth = 0;
+    unsigned resizeHeight = 0;
+    SkFilterQuality resizeQuality = kLow_SkFilterQuality;
+    parseOptions(options, flipY, premultiplyAlpha, resizeWidth, resizeHeight, resizeQuality);
 
     if (flipY || !premultiplyAlpha) {
         RefPtr<SkImage> skiaImage = buffer->newSkImageSnapshot(PreferNoAcceleration, SnapshotReasonUnknown);
         if (flipY)
             skiaImage = flipSkImageVertically(skiaImage.get(), PremultiplyAlpha);
         if (!premultiplyAlpha)
             skiaImage = premulSkImageToUnPremul(skiaImage.get());
         m_image = StaticBitmapImage::create(skiaImage.release());
     } else {
         m_image = StaticBitmapImage::create(buffer->newSkImageSnapshot(PreferNoAcceleration, SnapshotReasonUnknown));
     }
     m_image->setOriginClean(!video->wouldTaintOrigin(document->getSecurityOrigin()));
     m_image->setPremultiplied(premultiplyAlpha);
 }
 
-ImageBitmap::ImageBitmap(HTMLCanvasElement* canvas, const IntRect& cropRect, const ImageBitmapOptions& options)
+ImageBitmap::ImageBitmap(HTMLCanvasElement* canvas, IntRect& cropRect, const ImageBitmapOptions& options)
 {
     ASSERT(canvas->isPaintable());
     bool flipY;
     bool premultiplyAlpha;
-    parseOptions(options, flipY, premultiplyAlpha);
+    unsigned resizeWidth = 0;
+    unsigned resizeHeight = 0;
+    SkFilterQuality resizeQuality = kLow_SkFilterQuality;
+    parseOptions(options, flipY, premultiplyAlpha, resizeWidth, resizeHeight, resizeQuality);
+
+    RefPtr<Image> input = canvas->copiedImage(BackBuffer, PreferAcceleration);
+    if (options.hasResizeWidth() && options.hasResizeHeight()
+        && (static_cast<int>(resizeWidth) != input->width() || static_cast<int>(resizeHeight) != input->height())) {
+        scaleCropRect(cropRect, input->width(), input->height(), resizeWidth, resizeHeight);
+        input = scaleInput(input.get(), resizeWidth, resizeHeight, resizeQuality);
+    }
 
     // canvas is always premultiplied, so set the last parameter to true and convert to un-premul later
-    m_image = cropImage(canvas->copiedImage(BackBuffer, PreferAcceleration).get(), cropRect, flipY, true);
+    m_image = cropImage(input.get(), cropRect, flipY, true);
     if (!m_image)
         return;
     if (!premultiplyAlpha)
         m_image = StaticBitmapImage::create(premulSkImageToUnPremul(m_image->imageForCurrentFrame().get()));
     m_image->setOriginClean(canvas->originClean());
     m_image->setPremultiplied(premultiplyAlpha);
 }
 
 // The last two parameters are used for structure-cloning.
-ImageBitmap::ImageBitmap(ImageData* data, const IntRect& cropRect, const ImageBitmapOptions& options, const bool& isImageDataPremultiplied, const bool& isImageDataOriginClean)
+ImageBitmap::ImageBitmap(ImageData* data, IntRect& cropRect, const ImageBitmapOptions& options, const bool& isImageDataPremultiplied, const bool& isImageDataOriginClean)
 {
     bool flipY;
     bool premultiplyAlpha;
-    parseOptions(options, flipY, premultiplyAlpha);
+    unsigned resizeWidth = 0;
+    unsigned resizeHeight = 0;
+    SkFilterQuality resizeQuality = kLow_SkFilterQuality;
+    parseOptions(options, flipY, premultiplyAlpha, resizeWidth, resizeHeight, resizeQuality);
     IntRect srcRect = intersection(cropRect, IntRect(IntPoint(), data->size()));
 
     // treat non-premultiplyAlpha as a special case
     if (!premultiplyAlpha) {
         unsigned char* srcAddr = data->data()->data();
         int srcHeight = data->size().height();
         int dstHeight = cropRect.height();
         // TODO (xidachen): skia doesn't support SkImage::NewRasterCopy from a kRGBA color type.
         // For now, we swap R and B channel and uses kBGRA color type.
         SkImageInfo info;
@@ skipping 58 matching lines @@
         dstPoint.setX(-cropRect.x());
     if (cropRect.y() < 0)
         dstPoint.setY(-cropRect.y());
     buffer->putByteArray(Unmultiplied, data->data()->data(), data->size(), srcRect, dstPoint);
     if (flipY)
         m_image = StaticBitmapImage::create(flipSkImageVertically(buffer->newSkImageSnapshot(PreferNoAcceleration, SnapshotReasonUnknown).get(), PremultiplyAlpha));
     else
         m_image = StaticBitmapImage::create(buffer->newSkImageSnapshot(PreferNoAcceleration, SnapshotReasonUnknown));
 }
 
-ImageBitmap::ImageBitmap(ImageBitmap* bitmap, const IntRect& cropRect, const ImageBitmapOptions& options)
+ImageBitmap::ImageBitmap(ImageBitmap* bitmap, IntRect& cropRect, const ImageBitmapOptions& options)
 {
     bool flipY;
     bool premultiplyAlpha;
-    parseOptions(options, flipY, premultiplyAlpha);
-    m_image = cropImage(bitmap->bitmapImage(), cropRect, flipY, premultiplyAlpha, bitmap->isPremultiplied() ? PremultiplyAlpha : DontPremultiplyAlpha);
+    unsigned resizeWidth = 0;
+    unsigned resizeHeight = 0;
+    SkFilterQuality resizeQuality = kLow_SkFilterQuality;
+    parseOptions(options, flipY, premultiplyAlpha, resizeWidth, resizeHeight, resizeQuality);
+
+    RefPtr<Image> input = bitmap->bitmapImage();
+    if (options.hasResizeWidth() && options.hasResizeHeight()
+        && (static_cast<int>(resizeWidth) != input->width() || static_cast<int>(resizeHeight) != input->height())) {
+        scaleCropRect(cropRect, input->width(), input->height(), resizeWidth, resizeHeight);
+        input = scaleInput(input.get(), resizeWidth, resizeHeight, resizeQuality);
+    }
+
+    m_image = cropImage(input.get(), cropRect, flipY, premultiplyAlpha, bitmap->isPremultiplied() ? PremultiplyAlpha : DontPremultiplyAlpha);
     if (!m_image)
         return;
     m_image->setOriginClean(bitmap->originClean());
     m_image->setPremultiplied(premultiplyAlpha);
 }
 
-ImageBitmap::ImageBitmap(PassRefPtr<StaticBitmapImage> image, const IntRect& cropRect, const ImageBitmapOptions& options)
+ImageBitmap::ImageBitmap(PassRefPtr<StaticBitmapImage> image, IntRect& cropRect, const ImageBitmapOptions& options)
 {
     bool flipY;
     bool premultiplyAlpha;
-    parseOptions(options, flipY, premultiplyAlpha);
-    m_image = cropImage(image.get(), cropRect, flipY, premultiplyAlpha, DontPremultiplyAlpha);
+    unsigned resizeWidth = 0;
+    unsigned resizeHeight = 0;
+    SkFilterQuality resizeQuality = kLow_SkFilterQuality;
+    parseOptions(options, flipY, premultiplyAlpha, resizeWidth, resizeHeight, resizeQuality);

[jbroman, 2016/06/29 21:14:42]

This is getting to be quite a few options; have you considered returning a
struct of resolved options instead of a long parameter list?

[xidachen, 2016/06/30 15:23:12]

Done.

+
+    bool originClean = image->originClean();
+    RefPtr<Image> input = image;
+    if (options.hasResizeWidth() && options.hasResizeHeight()

[jbroman, 2016/06/29 21:14:41]

nit: It seems a little odd to duplicate the "should we resize" condition here.
Should the parseOptions thing be deciding that and producing a boolean?

[xidachen, 2016/06/30 15:23:11]

Done.

+        && (static_cast<int>(resizeWidth) != input->width() || static_cast<int>(resizeHeight) != input->height())) {
+        scaleCropRect(cropRect, input->width(), input->height(), resizeWidth, resizeHeight);

[jbroman, 2016/06/29 21:14:41]

A lot of this logic is duplicated with the above function; can this be
refactored to duplicate less code?

[xidachen, 2016/06/30 15:23:11]

Done.

+        input = scaleInput(input.get(), resizeWidth, resizeHeight, resizeQuality);
+    }
+
+    m_image = cropImage(input.get(), cropRect, flipY, premultiplyAlpha, DontPremultiplyAlpha);
     if (!m_image)
         return;
-    m_image->setOriginClean(image->originClean());
+    m_image->setOriginClean(originClean);
     m_image->setPremultiplied(premultiplyAlpha);
 }
 
 ImageBitmap::ImageBitmap(PassRefPtr<StaticBitmapImage> image)
 {
     m_image = image;
 }
 
 ImageBitmap::ImageBitmap(WebExternalTextureMailbox& mailbox)
 {
@@ skipping 109 matching lines @@
 
 ScriptPromise ImageBitmap::createImageBitmap(ScriptState* scriptState, EventTarget& eventTarget, int sx, int sy, int sw, int sh, const ImageBitmapOptions& options, ExceptionState& exceptionState)
 {
     if (!sw || !sh) {
         exceptionState.throwDOMException(IndexSizeError, String::format("The source %s provided is 0.", sw ? "height" : "width"));
         return ScriptPromise();
     }
     return ImageBitmapSource::fulfillImageBitmap(scriptState, create(this, IntRect(sx, sy, sw, sh), options));
 }
 
-void ImageBitmap::parseOptions(const ImageBitmapOptions& options, bool& flipY, bool& premultiplyAlpha)
+void ImageBitmap::parseOptions(const ImageBitmapOptions& options, bool& flipY, bool& premultiplyAlpha, unsigned& resizeWidth, unsigned& resizeHeight, SkFilterQuality& resizeQuality)
 {
     if (options.imageOrientation() == imageOrientationFlipY) {
         flipY = true;
     } else {
         flipY = false;
         ASSERT(options.imageOrientation() == imageBitmapOptionNone);
     }
     if (options.premultiplyAlpha() == imageBitmapOptionNone) {
         premultiplyAlpha = false;
     } else {
         premultiplyAlpha = true;
         ASSERT(options.premultiplyAlpha() == "default" || options.premultiplyAlpha() == "premultiply");
     }
+    if (options.hasResizeWidth() && options.hasResizeHeight()) {

[jbroman, 2016/06/29 21:14:41]

What if one is provided but not the other? Your spec change seems vague on this
point.

I could imagine a couple behaviors that might be reasonable:
- scale proportionally, like <img> does
- use the original size in the unspecified dimension
- throw an exception

"Silently ignore" seems unlikely to be the right option here. WDYT?

[xidachen, 2016/06/30 15:23:11]

Changed to scale proportionally, will have a pull request to change the spec.

+        resizeWidth = options.resizeWidth();
+        resizeHeight = options.resizeHeight();
+        if (options.resizeQuality() == "high")
+            resizeQuality = kHigh_SkFilterQuality;
+        else if (options.resizeQuality() == "medium")
+            resizeQuality = kMedium_SkFilterQuality;
+        else if (options.resizeQuality() == "pixelated")
+            resizeQuality = kNone_SkFilterQuality;
+        else
+            DCHECK_EQ(options.resizeQuality(), "low");
+    }
 }
 
 PassRefPtr<Image> ImageBitmap::getSourceImageForCanvas(SourceImageStatus* status, AccelerationHint, SnapshotReason, const FloatSize&) const
 {
     *status = NormalSourceImageStatus;
     return m_image ? m_image : nullptr;
 }
 
 void ImageBitmap::adjustDrawRects(FloatRect* srcRect, FloatRect* dstRect) const
 {
 }
 
 FloatSize ImageBitmap::elementSize(const FloatSize&) const
 {
     return FloatSize(width(), height());
 }
 
 DEFINE_TRACE(ImageBitmap)
 {
 }
 
 } // namespace blink