Implement resize option for createImageBitmap(HTMLVideoElement)

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 10 matching lines @@
 static const char* imageBitmapOptionNone = "none";
 
 namespace {
 
 struct ParsedOptions {
     bool flipY = false;
     bool premultiplyAlpha = true;
     bool shouldScaleInput = false;
     unsigned resizeWidth = 0;
     unsigned resizeHeight = 0;
+    float scaleRatioX = 1;
+    float scaleRatioY = 1;
     IntRect cropRect;
     SkFilterQuality resizeQuality = kLow_SkFilterQuality;
 };
 
 // The following two functions are helpers used in cropImage
 static inline IntRect normalizeRect(const IntRect& rect)
 {
     return IntRect(std::min(rect.x(), rect.maxX()),
         std::min(rect.y(), rect.maxY()),
         std::max(rect.width(), -rect.width()),
         std::max(rect.height(), -rect.height()));
 }
 
 static bool frameIsValid(const SkBitmap& frameBitmap)
 {
     ASSERT(!frameBitmap.isNull() && !frameBitmap.empty() && frameBitmap.isImmutable());
     return frameBitmap.colorType() == kN32_SkColorType;
 }
 
-ParsedOptions parseOptions(const ImageBitmapOptions& options, Optional<IntRect> cropRect, IntSize sourceSize)
+ParsedOptions parseOptions(const ImageBitmapOptions& options, Optional<IntRect> cropRect, IntSize sourceSize, bool shouldCalculateRatio)
 {
     ParsedOptions parsedOptions;
     if (options.imageOrientation() == imageOrientationFlipY) {
         parsedOptions.flipY = true;
     } else {
         parsedOptions.flipY = false;
         DCHECK(options.imageOrientation() == imageBitmapOptionNone);
     }
     if (options.premultiplyAlpha() == imageBitmapOptionNone) {
         parsedOptions.premultiplyAlpha = false;
@@ skipping 20 matching lines @@
         parsedOptions.resizeHeight = ceil(static_cast<float>(options.resizeWidth()) / parsedOptions.cropRect.width() * parsedOptions.cropRect.height());
     } else {
         parsedOptions.resizeHeight = options.resizeHeight();
         parsedOptions.resizeWidth = ceil(static_cast<float>(options.resizeHeight()) / parsedOptions.cropRect.height() * parsedOptions.cropRect.width());
     }
     if (static_cast<int>(parsedOptions.resizeWidth) == parsedOptions.cropRect.width() && static_cast<int>(parsedOptions.resizeHeight) == parsedOptions.cropRect.height()) {
         parsedOptions.shouldScaleInput = false;
         return parsedOptions;
     }
     parsedOptions.shouldScaleInput = true;
+    if (shouldCalculateRatio) {
+        parsedOptions.scaleRatioX = static_cast<float>(parsedOptions.resizeWidth) / parsedOptions.cropRect.width();
+        parsedOptions.scaleRatioY = static_cast<float>(parsedOptions.resizeHeight) / parsedOptions.cropRect.height();
+    }
 
     if (options.resizeQuality() == "high")
         parsedOptions.resizeQuality = kHigh_SkFilterQuality;
     else if (options.resizeQuality() == "medium")
         parsedOptions.resizeQuality = kMedium_SkFilterQuality;
     else if (options.resizeQuality() == "pixelated")
         parsedOptions.resizeQuality = kNone_SkFilterQuality;
     else
         parsedOptions.resizeQuality = kLow_SkFilterQuality;
     return parsedOptions;
@@ skipping 174 matching lines @@
         if (imageFormat == PremultiplyAlpha)
             return StaticBitmapImage::create(unPremulSkImageToPremul(skiaImage.get()));
         return StaticBitmapImage::create(skiaImage.release());
     }
     return StaticBitmapImage::create(premulSkImageToUnPremul(skiaImage.get()));
 }
 
 ImageBitmap::ImageBitmap(HTMLImageElement* image, Optional<IntRect> cropRect, Document* document, const ImageBitmapOptions& options)
 {
     RefPtr<Image> input = image->cachedImage()->getImage();
-    ParsedOptions parsedOptions = parseOptions(options, cropRect, image->bitmapSourceSize());
+    ParsedOptions parsedOptions = parseOptions(options, cropRect, image->bitmapSourceSize(), false);
 
     if (options.colorSpaceConversion() == "none")
         m_image = cropImage(input.get(), parsedOptions, PremultiplyAlpha, ImageDecoder::GammaAndColorProfileIgnored);
     else
         m_image = cropImage(input.get(), parsedOptions, 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(parsedOptions.premultiplyAlpha);
 }
 
 ImageBitmap::ImageBitmap(HTMLVideoElement* video, Optional<IntRect> cropRect, Document* document, const ImageBitmapOptions& options)
 {
     IntSize playerSize;
     if (video->webMediaPlayer())
         playerSize = video->webMediaPlayer()->naturalSize();
-
-    // TODO(xidachen); implement the resize option.
-    ParsedOptions parsedOptions = parseOptions(options, cropRect, video->bitmapSourceSize());
+    ParsedOptions parsedOptions = parseOptions(options, cropRect, video->bitmapSourceSize(), true);
 
     IntRect videoRect = IntRect(IntPoint(), playerSize);
     IntRect srcRect = intersection(parsedOptions.cropRect, videoRect);
-    std::unique_ptr<ImageBuffer> buffer = ImageBuffer::create(parsedOptions.cropRect.size(), NonOpaque, DoNotInitializeImagePixels);
+    std::unique_ptr<ImageBuffer> buffer = ImageBuffer::create(IntSize(parsedOptions.resizeWidth, parsedOptions.resizeHeight), NonOpaque, DoNotInitializeImagePixels);
     if (!buffer)
         return;
 
     if (parsedOptions.flipY) {
         buffer->canvas()->translate(0, buffer->size().height());
         buffer->canvas()->scale(1, -1);
     }
     IntPoint dstPoint = IntPoint(std::max(0, -parsedOptions.cropRect.x()), std::max(0, -parsedOptions.cropRect.y()));
-    video->paintCurrentFrame(buffer->canvas(), IntRect(dstPoint, srcRect.size()), nullptr);
+    IntSize dstSize = srcRect.size();
+    SkPaint paint;
+    if (parsedOptions.shouldScaleInput) {
+        dstPoint.scale(parsedOptions.scaleRatioX, parsedOptions.scaleRatioY);

[Justin Novosad, 2016/07/29 15:08:52]

putting the scaleRAtion in parsedOptions is overkill IMHO.  they should just be
locals in this function. It adds unnecessary complexity to the shared parsing
function.  Not to mention that the bool arg is bad for readability.

[xidachen, 2016/07/29 17:22:10]

Yes, that makes perfect sense. Changed in the new PS.

+        paint.setFilterQuality(parsedOptions.resizeQuality);
+        dstSize.scale(parsedOptions.scaleRatioX, parsedOptions.scaleRatioY);
+    }
+    video->paintCurrentFrame(buffer->canvas(), IntRect(dstPoint, dstSize), parsedOptions.shouldScaleInput ? &paint : nullptr);
 
     RefPtr<SkImage> skiaImage = buffer->newSkImageSnapshot(PreferNoAcceleration, SnapshotReasonUnknown);
     if (!parsedOptions.premultiplyAlpha)
         skiaImage = premulSkImageToUnPremul(skiaImage.get());
     m_image = StaticBitmapImage::create(skiaImage.release());
     m_image->setOriginClean(!video->wouldTaintOrigin(document->getSecurityOrigin()));
     m_image->setPremultiplied(parsedOptions.premultiplyAlpha);
 }
 
 ImageBitmap::ImageBitmap(HTMLCanvasElement* canvas, Optional<IntRect> cropRect, const ImageBitmapOptions& options)
 {
     ASSERT(canvas->isPaintable());
     RefPtr<Image> input = canvas->copiedImage(BackBuffer, PreferAcceleration);
-    ParsedOptions parsedOptions = parseOptions(options, cropRect, canvas->bitmapSourceSize());
+    ParsedOptions parsedOptions = parseOptions(options, cropRect, canvas->bitmapSourceSize(), false);
 
     bool isPremultiplyAlphaReverted = false;
     if (!parsedOptions.premultiplyAlpha) {
         parsedOptions.premultiplyAlpha = true;
         isPremultiplyAlphaReverted = true;
     }
     m_image = cropImage(input.get(), parsedOptions);
     if (!m_image)
         return;
     if (isPremultiplyAlphaReverted) {
@@ skipping 21 matching lines @@
     return fromSkSp(SkImage::MakeFromRaster(pixmap, [](const void* pixels, void*)
         {
             delete[] static_cast<const uint8_t*>(pixels);
         }, nullptr));
 }
 
 ImageBitmap::ImageBitmap(ImageData* data, Optional<IntRect> cropRect, const ImageBitmapOptions& options)
 {
     // TODO(xidachen): implement the resize option
     IntRect dataSrcRect = IntRect(IntPoint(), data->size());
-    ParsedOptions parsedOptions = parseOptions(options, cropRect, data->bitmapSourceSize());
+    ParsedOptions parsedOptions = parseOptions(options, cropRect, data->bitmapSourceSize(), false);
     IntRect srcRect = cropRect ? intersection(parsedOptions.cropRect, dataSrcRect) : dataSrcRect;
 
     // treat non-premultiplyAlpha as a special case
     if (!parsedOptions.premultiplyAlpha) {
         unsigned char* srcAddr = data->data()->data();
         int srcHeight = data->size().height();
         int dstHeight = parsedOptions.cropRect.height();
 
         // Using kN32 type, swizzle input if necessary.
         SkImageInfo info = SkImageInfo::Make(parsedOptions.cropRect.width(), dstHeight, kN32_SkColorType, kUnpremul_SkAlphaType);
@@ skipping 80 matching lines @@
         skImage = fromSkSp(surface->makeImageSnapshot());
     }
     m_image = StaticBitmapImage::create(skImage);
 }
 
 ImageBitmap::ImageBitmap(ImageBitmap* bitmap, Optional<IntRect> cropRect, const ImageBitmapOptions& options)
 {
     RefPtr<Image> input = bitmap->bitmapImage();
     if (!input)
         return;
-    ParsedOptions parsedOptions = parseOptions(options, cropRect, input->size());
+    ParsedOptions parsedOptions = parseOptions(options, cropRect, input->size(), false);
 
     m_image = cropImage(input.get(), parsedOptions, bitmap->isPremultiplied() ? PremultiplyAlpha : DontPremultiplyAlpha);
     if (!m_image)
         return;
     m_image->setOriginClean(bitmap->originClean());
     m_image->setPremultiplied(parsedOptions.premultiplyAlpha);
 }
 
 ImageBitmap::ImageBitmap(PassRefPtr<StaticBitmapImage> image, Optional<IntRect> cropRect, const ImageBitmapOptions& options)
 {
     bool originClean = image->originClean();
     RefPtr<Image> input = image;
-    ParsedOptions parsedOptions = parseOptions(options, cropRect, input->size());
+    ParsedOptions parsedOptions = parseOptions(options, cropRect, input->size(), false);
 
     m_image = cropImage(input.get(), parsedOptions, DontPremultiplyAlpha);
     if (!m_image)
         return;
     m_image->setOriginClean(originClean);
     m_image->setPremultiplied(parsedOptions.premultiplyAlpha);
 }
 
 ImageBitmap::ImageBitmap(PassRefPtr<StaticBitmapImage> image)
 {
@@ skipping 134 matching lines @@
 FloatSize ImageBitmap::elementSize(const FloatSize&) const
 {
     return FloatSize(width(), height());
 }
 
 DEFINE_TRACE(ImageBitmap)
 {
 }
 
 } // namespace blink